हास्केल रेगेक्स प्रदर्शन

Question

मैं हास्केल में रेगेक्स के मौजूदा विकल्पों को देख रहा हूं, और मैं समझना चाहता था कि प्रदर्शन में अंतर एक दूसरे के साथ विभिन्न विकल्पों की तुलना करते समय और खासकर grep के लिए एक सरल कॉल के साथ कहां से आया था .. ।

$ du radixtracefile 
113120 radixtracefile 
$ wc -l radixtracefile 
1051565 radixtracefile 

---

• मैं पहली बार कैसे पता लगाने की कोशिश:

  मैं एक अपेक्षाकृत छोटे (~ 110M, तो मेरा उपयोग अधिकांश मामलों में जी की एक सामान्य कई 10s की तुलना में) का पता लगाने फ़ाइल है (मनमानी) के कई मैचों

$ time grep -nE ".*504.*ll" radixtracefile | wc -l 
309 

real 0m0.211s 
user 0m0.202s 
sys 0m0.010s 

---

• मैं Text.Regex.TDFA को देखा (संस्करण 1.2.1) Data.ByteString साथ:

import Control.Monad.Loops 
import Data.Maybe 
import qualified Data.Text as T 
import qualified Data.Text.IO as TIO 
import Text.Regex.TDFA 
import qualified Data.ByteString as B 

main = do 
    f <- B.readFile "radixtracefile" 
    matches :: [[B.ByteString]] <- f =~~ ".*504.*ll" 
    mapM_ (putStrLn . show . head) matches 

पैटर्न .*504.*ll ग्रेप के माध्यम से वहाँ में थे भवन और चलाना:

$ ghc -O2 test-TDFA.hs -XScopedTypeVariables 
[1 of 1] Compiling Main    (test-TDFA.hs, test-TDFA.o) 
Linking test-TDFA ... 
$ time ./test-TDFA | wc -l 
309 

real 0m4.463s 
user 0m4.431s 
sys 0m0.036s 

---

• फिर, मैं Data.Text.ICU.Regex को देखा यूनिकोड समर्थन के साथ (संस्करण 0.7.0.1):

import Control.Monad.Loops 
import qualified Data.Text as T 
import qualified Data.Text.IO as TIO 
import Data.Text.ICU.Regex 

main = do 
    re <- regex [] $ T.pack ".*504.*ll" 
    f <- TIO.readFile "radixtracefile" 
    setText re f 
    whileM_ (findNext re) $ do 
     a <- start re 0 
     putStrLn $ "last match at :"++(show a) 

बिल्डिंग और चल रहा है:

$ ghc -O2 test-ICU.hs 
[1 of 1] Compiling Main    (test-ICU.hs, test-ICU.o) 
Linking test-ICU ... 
$ time ./test-ICU | wc -l 
309 

real 1m36.407s 
user 1m36.090s 
sys 0m0.169s 

---

मैं ghc संस्करण 7.6.3 का उपयोग करता हूं। मुझे अन्य हास्केल रेगेक्स विकल्पों का परीक्षण करने का मौका नहीं मिला है। मुझे पता था कि मुझे जीईपी के साथ प्रदर्शन नहीं मिलेगा और इससे खुश होने के अलावा, लेकिन टीडीएफए और बाइटस्ट्रिंग के लिए 20 गुना धीमी है ... यह बहुत डरावना है। और मैं वास्तव में समझ नहीं पा रहा हूं कि यह क्यों है, क्योंकि मैं मूर्खतापूर्ण हूं कि यह देशी बैकएंड पर एक रैपर था ... क्या मैं किसी भी तरह से मॉड्यूल का सही ढंग से उपयोग नहीं कर रहा हूं?

(और चलो आईसीयू + पाठ कॉम्बो जो छत से गुजर रहा है का उल्लेख नहीं है)

वहाँ एक विकल्प है कि मैं अभी तक परीक्षण नहीं किया है कि मुझे खुश होगा है?

संपादित:

• Text.Regex.PCRE Data.ByteString साथ (संस्करण 0.94.4):

import Control.Monad.Loops 
import Data.Maybe 
import Text.Regex.PCRE 
import qualified Data.ByteString as B 

main = do 
    f <- B.readFile "radixtracefile" 
    matches :: [[B.ByteString]] <- f =~~ ".*504.*ll" 
    mapM_ (putStrLn . show . head) matches 

बिल्डिंग और चल रहा है:

$ ghc -O2 test-PCRE.hs -XScopedTypeVariables 
[1 of 1] Compiling Main    (test-PCRE.hs, test-PCRE.o) 
Linking test-PCRE ... 
$ time ./test-PCRE | wc -l 
309 

real 0m1.442s 
user 0m1.412s 
sys 0m0.031s 

बेहतर, लेकिन अभी भी ~ 7-ish के कारक के साथ ...

Answer 1

तो, थोड़ी देर के लिए अन्य पुस्तकालयों को देखने के बाद, मैंने पीसीआरई की कोशिश की। लिगथ (संस्करण 0.4.0।4):

import Control.Monad 
import Text.Regex.PCRE.Light 
import qualified Data.ByteString.Char8 as B 

main = do 
    f <- B.readFile "radixtracefile" 
    let lines = B.split '\n' f 
    let re = compile (B.pack ".*504.*ll") [] 
    forM_ lines $ \l -> maybe (return()) print $ match re l [] 

यहाँ मुझे लगता है कि से बाहर निकलना है:

$ ghc -O2 test-PCRELight.hs -XScopedTypeVariables 
[1 of 1] Compiling Main    (test-PCRELight.hs, test-PCRELight.o) 
Linking test-PCRELight ... 
$ time ./test-PCRELight | wc -l 
309 

real 0m0.832s 
user 0m0.803s 
sys 0m0.027s 

मुझे लगता है कि यह मेरी प्रयोजनों के लिए पर्याप्त सभ्य है। मैं यह देखने की कोशिश कर सकता हूं कि अन्य libs के साथ क्या होता है जब मैं मैन्युअल रूप से लाइन विभाजन को मैन्युअल रूप से करता हूं, हालांकि मुझे संदेह है कि यह एक बड़ा अंतर बनाने जा रहा है।