2013-10-04 7 views
5

मैं अपना कोड अनुकूलित करना चाहता हूं।लुआ मेमोरी को अनुकूलित करें

1)

local Test = {} 
    Test.var1 = function() 
     -- Code 
    end 

    Test.var2 = function() 
     -- Code 
    end 

2) या

function var1() 
    -- Code 
end 

function var2() 
    -- Code 
end 

3) या हो सकता है

local var1 = function() 
    -- Code 
end 

local var2 = function() 
    -- Code 
end 
+0

तीसरा मुझे लगता है कि दूसरे से बेहतर है, लेकिन सुनिश्चित नहीं है कि – itdxer

+6

आप [यहां अनुकूलित करें] (http://c2.com/cgi/wiki?PrematureOptimization) क्या चाहते हैं? यदि आप ऑब्जेक्ट उन्मुख-जैसी संरचना चाहते हैं, तो पहले का उपयोग करें, यदि आप ग्लोबल्स को कहीं भी एक्सेस करना चाहते हैं, तो दूसरे (2 फ़ंक्शंस महंगे नहीं हैं) का उपयोग करें, यदि आप अपने स्थानीय दायरे में दिखाई देने वाले फ़ंक्शंस चाहते हैं, तो तीसरे विकल्प का उपयोग करें । –

+4

यह * मेमोरी * अनुकूलित करने से कैसे संबंधित है? – lhf

उत्तर

7

: मैं 3 विकल्प नहीं जानता कि जो लुआ में स्मृति के लिए बेहतर है है Lua Programming Gem से उद्धरण, प्रोग्राम अनुकूलन के दो अधिकतम:

  • नियम # 1: ऐसा मत करो।
  • नियम # 2: अभी तक ऐसा न करें। (केवल विशेषज्ञों के लिए)

आपके उदाहरणों पर वापस, कोड का दूसरा टुकड़ा थोड़ा खराब है क्योंकि वैश्विक लोगों तक पहुंच धीमी है। लेकिन प्रदर्शन अंतर शायद ही ध्यान देने योग्य है।

यह आपकी आवश्यकताओं पर निर्भर करता है, पहला व्यक्ति तीसरे की तुलना में अतिरिक्त तालिका का उपयोग करता है, लेकिन नेमस्पेस क्लीनर है।

2

कोई भी वास्तव में # 1 में किसी तालिका के उपयोग को छोड़कर स्मृति को प्रभावित नहीं करेगा (इसलिए कुछ 40 बाइट्स + प्रति प्रविष्टि)।

यदि आपका प्रदर्शन आप चाहते हैं, तो विकल्प # 3 कहीं बेहतर है, मानते हुए कि आप स्थानीय दायरे में दिए गए कार्यों तक पहुंच सकते हैं।

0

यदि यह प्रसंस्करण से अधिक स्मृति उपयोग के बारे में है और आप ऑब्जेक्ट उन्मुख प्रोग्रामिंग का उपयोग कर रहे हैं, जहां आप ऊपर दिखाए गए Test के कई उदाहरणों को तुरंत चालू कर रहे हैं, तो आपके पास मेटाटेबल्स के साथ चौथा विकल्प है।

TestMt = {} 
TestMt.func1 = function(self, ...) 
    ... 
end 
TestMt.func2 = function(self, ...) 
    ... 
end 
TestMt.func3 = function(self, ...) 
    ... 
end 

function new_test() 
    local t = {} 
    t.data = ... 
    setmetatable(t, {__index = TestMt}) 
    return t 
end 

foo = new_test() 
foo:func1() 
foo:func2() 
foo:func3() 

आप प्रोग्रामिंग की वस्तु उन्मुख तरह कर रहे हैं, metatables स्मृति में एक बड़े पैमाने पर बचत करने के लिए नेतृत्व कर सकते हैं (मैं गलती से 1 गीगाबाइट से अधिक एक बार कई गणितीय वैक्टर के लिए इस तरह से इस्तेमाल किया है, केवल 40 के लिए नीचे कम करने के लिए मेटाटेबल का उपयोग करके मेगाबाइट्स)।

यदि यह ऑब्जेक्ट्स और टेबलों के बारे में नहीं है जो कई बार तत्काल प्राप्त होते हैं, और केवल आपके वैश्विक रूप से सुलभ कार्यों को व्यवस्थित करने के बारे में, यहां स्मृति के बारे में चिंता करना हास्यास्पद है। यह फ़ाइल सिस्टम ओवरहेड को कम करने के लिए आपके लूआ कोड की संपूर्णता को एक फ़ाइल में डालने जैसा है। आप इस तरह की नगण्य बचत के बारे में बात कर रहे हैं कि आपको वास्तव में असाधारण उपयोग के मामले में सावधानीपूर्वक उपयोग करने की आवश्यकता होनी चाहिए ताकि आप इससे भी चिंता कर सकें।

यदि यह प्रसंस्करण के बारे में है, तो आप अपने वैश्विक कार्यों को नेस्टेड टेबल से बाहर रखकर और स्थानीय होने पर स्थानीय लोगों के पक्ष में कुछ छोटे सुधार प्राप्त कर सकते हैं।