जीएचसी

Question

के साथ बहुत बड़े स्थिरांक संकलित आज मैंने जीएचसी से 8 एमबी हास्केल स्रोत फ़ाइल संकलित करने के लिए कहा। जीएचसी ने लगभग 6 मिनट के लिए इसके बारे में सोचा, लगभग 2 जीबी रैम निगल लिया, और फिर आखिरकार एक आउट-ऑफ-मेमोरी त्रुटि छोड़ दी।

[एक अलग रूप में के रूप में, मैं कर रहा हूँ खुशी है कि GHC बल्कि मंजिल से मेरे पूरे पीसी निरस्त करने के लिए अच्छी समझ थी।]

मूल रूप से मैं एक प्रोग्राम है जो एक पाठ फ़ाइल पढ़ता है मिल गया है, कुछ फैंसी पार्स करता है, एक डेटा संरचना बनाता है और फिर फ़ाइल में डंप करने के लिए show का उपयोग करता है। मेरे अंतिम आवेदन में संपूर्ण पार्सर और स्रोत डेटा को शामिल करने के बजाय, मैं जेनरेट किए गए डेटा को संकलन-समय निरंतर के रूप में शामिल करना चाहता हूं। show से आउटपुट में कुछ अतिरिक्त सामान जोड़कर, आप इसे एक वैध हास्केल मॉड्यूल बना सकते हैं। लेकिन जीएचसी स्पष्ट रूप से बहु-एमबी स्रोत फ़ाइलों को संकलित करने का आनंद नहीं लेता है।

(अजीब हिस्सा है, अगर आप सिर्फ read डेटा वापस, यह वास्तव में बहुत ज्यादा नहीं समय या स्मृति ले करता है। अजीब, यह देखते हुए कि दोनों String आई/ओ और read माना जाता है कि बहुत अक्षम हैं ...)

मुझे अस्पष्टता से याद है कि अन्य लोगों को अतीत में बड़ी फ़ाइलों को संकलित करने के लिए जीएचसी प्राप्त करने में परेशानी हुई है। एफडब्ल्यूआईडब्ल्यू, मैंने -O0 का उपयोग करने की कोशिश की, जिसने दुर्घटना तेज कर दी लेकिन इसे रोक नहीं दिया। तो हैस्केल प्रोग्राम में बड़े संकलन-समय स्थिरांक को शामिल करने का सबसे अच्छा तरीका है?

(मेरे मामले में, लगातार सिर्फ कुछ रोचक लेबल के साथ एक नेस्टेड Data.Map है।)

शुरू में मैंने सोचा था कि GHC केवल एक पंक्ति है कि अस्सी लाख वर्ण लंबा से मिलकर एक मॉड्यूल पढ़ने से नाखुश हो सकता है। (!!) लेआउट नियम या ऐसे के साथ कुछ करना है। या शायद गहराई से घिरे अभिव्यक्ति इसे परेशान करते हैं। लेकिन मैंने प्रत्येक सबएक्सप्रेस को एक शीर्ष-स्तरीय पहचानकर्ता बनाने की कोशिश की, और यह कोई मदद नहीं थी। (प्रत्येक पर स्पष्ट प्रकार के हस्ताक्षर जोड़ना संकलक को थोड़ा अधिक खुश करने के लिए प्रतीत होता है।) क्या कुछ और है जो मैं संकलक के काम को सरल बनाने की कोशिश कर सकता हूं?

अंत में, मैं डेटा-संरचना बनाने में सक्षम था, मैं वास्तव में बहुत छोटा स्टोर करने की कोशिश कर रहा हूं। (जैसे, 300 केबी।) इसने जीएचसी को बहुत खुश कर दिया। (और अंतिम आवेदन बहुत तेज है।) लेकिन भविष्य के संदर्भ के लिए, मुझे यह जानने में दिलचस्पी होगी कि इस तक पहुंचने का सबसे अच्छा तरीका क्या है।

Answer 1

आपकी सर्वश्रेष्ठ शर्त संभवतः निष्पादन योग्य में आपके मान का एक स्ट्रिंग प्रतिनिधित्व संकलित करने के लिए है। इसे साफ तरीके से करने के लिए, कृपया my answer in a previous question देखें।

इसका इस्तेमाल करने के लिए बस myExpression.exp में अपनी अभिव्यक्ति की दुकान और QuasiQuotes विस्तार के साथ read [litFile|myExpression.exp|] करना सक्षम है, और अभिव्यक्ति निष्पादन में "एक स्ट्रिंग शाब्दिक रूप में जमा" कर दिया जाएगा।

---

मैं वास्तविक स्थिरांक के भंडारण के लिए कुछ इसी तरह कर रही कोशिश की, लेकिन यह एक ही कारण एक .hs फ़ाइल में मूल्य हैं embedding कि के लिए विफल रहता है।मेरे प्रयास किया गया था:

Verbatim.hs:

module Verbatim where 

import Language.Haskell.TH 
import Language.Haskell.TH.Quote 
import Language.Haskell.Meta.Parse 

readExp :: String -> Q Exp 
readExp = either fail return . parseExp 

verbatim :: QuasiQuoter 
verbatim = QuasiQuoter { quoteExp = readExp } 

verbatimFile :: QuasiQuoter 
verbatimFile = quoteFile verbatim 

टेस्ट कार्यक्रम:

{-# LANGUAGE QuasiQuotes #-} 
module Main (main) where 

import Verbatim 

main :: IO() 
main = print [verbatimFile|test.exp|] 

इस कार्यक्रम के छोटे test.exp फ़ाइलों के लिए काम करता है, लेकिन इस कंप्यूटर पर 2MiB बारे में पहले से ही विफल रहता है।

Answer 2

एक आसान समाधान है - आपके शाब्दिक प्रकार ByteString होना चाहिए। विवरण के लिए https://github.com/litherum/publicsuffixlist/pull/1 देखें।