Modul:Timing

Ushbu modulning maqsadi Lua-funksiyalarning ishlashini sozlash uchun vaqt tahlilini oʻtkazishning oddiy usulini taqdim etish, yaʼni funktsiyalarni profillash. Odatda funktsiya chaqiruvlarining davomiyligini oʻlchash qiyinchiliklar va muammoli kodlarni aniqlash boʻyicha katta saʼy-harakatlarning bir qismidir. Bu toʻliq profillovchi emas, chunki joriy oʻrnatishda chiziqni kuzatish (chaqiruv grafik profilini yaratish) mumkin emas. Uning yagona maqsadi — bajarilish vaqtini oʻlchash (tekis profil yaratish) va buni konsolidan (yaʼni, bitta funksiyada) interaktiv qilishdir.

Ushbu matnda bir necha bor aytilganidek; vaqt aniq emas va u faqat funksiyaning taxminiy ish vaqti va yukining qoʻpol oʻlchovi sifatida ishlatilishi kerak. Modul uchun ruxsat etilgan maksimal vaqt oraligʻiga moslashish uchun modulni sozlashga urinmang, chegaradan ancha pastroq turing!

Vaqt tahlili bajariladigan funksiya bilan chaqiriladi va ixtiyoriy ravishda har bir test toʻplamining soni (hajmi, standart 100) va shunga oʻxshash test toʻplamlarining soni (standart 10). Qoʻngʻiroqlarning umumiy soni × toʻplamlar soni boʻladi va funksiya uchun oʻrtacha ish vaqtini beradi. Standart ogʻish toʻplamlar sonidan hisoblanadi va faqat qoʻpol taxmin boʻladi. Agar faqat bitta toʻplam bilan ishlasangiz, standart ogʻish yoʻqoladi, lekin u oʻlchanmasa ham, bajarish vaqti oʻzgaradi.

Profiler jami qoʻngʻiroqlar boʻylab ikkita oʻtishni amalga oshiradi, biri qoʻgʻirchoq va ikkinchisi haqiqiy funktsiyaga ega. Bu qoʻshimcha kod qanchalik ogʻirligi haqida asosiy maʼlumotni olish imkonini beradi va keyin biz buni sinab koʻrayotgan funktsiya oʻlchovidan ayirishimiz mumkin. Agar tekshirilayotgan funktsiya sodda boʻlsa, bajarilish vaqtlari yaqin boʻladi va farqdagi noaniqlik yuqori boʻlishi mumkin. Agar bajarilish vaqti standart ogʻish bilan oʻxshash boʻlsa, tahlilni kattaroq yoki koʻproq toʻplamlar bilan qayta bajarish kerak.

Rivojlanish jarayonida maʼlum boʻldiki, 10 ta toʻplamda 100 ta qoʻngʻiroq odatda yaxshi baho olish uchun etarli, ammo bu raqamlarga ortiqcha vazn qoʻymaslik kerak. Agar bitta funktsiya ikki marta yoki daraxt vaqtlari yoki hatto oʻn barobar sekinroq boʻlsa, u doimiy yoki chiziqli vaqt ichida ishlayotgan ekan, bunga qarshi boʻlmang. Agar biror narsa 100 baravar sekinroq boʻlsa yoki uning eksponensial vaqtda ishlashini koʻrsatsa, unda boshqa algoritmlarni koʻrib chiqish kerak.

Foydalanish

Ushbu modul oddiy shablonlarda yoki sahifalarda foydalanish uchun emas, u modul sahifalarida tahrirlash oynasi ostidagi konsolida ishlatilishi kerak. Sinov muhitida moduldan foydalanish uchun pastga qarang. Oddiy funktsiyani sinab koʻrish

Masalan, Module:Example sahifasini ochamiz, deb faraz qilamiz, keyin p.hello() funksiyasini profillash uchun chaqiruv yozishimiz mumkin. Sahifadagi kod quyidagi misolga oʻxshaydi, ammo mahalliy versiyalar biroz boshqacha boʻlishi mumkin. (Hozirgi vaqtda shunga oʻxshash kod w:no:Module:HelloWorld2 da mavjud.)

Quyidagi kod Module:Examplening qisqartirilgan versiyasidir. Toʻliq versiya uchun sahifaga qarang.

local p = {};

p.hello = function(frame)
    local str = "Hello World!"
    return str
end

return p

Ushbu kodga kirish konsolidagi umumiy p orqali amalga oshiriladi. Oldingi kodni hisobga olsak, profilerni shunday deb atash mumkin.

=require 'Module:Timingʻ(p.hello)

Shunga oʻxshash bir xil turdagi modul uchun enwiki-da quyidagi kabi hisobotni yaratdi.

=require 'Module:Timing'(p.hello)
Each call was running for about 1.2e-09 seconds.
	Mean runtime for each set was 1.2e-07 seconds,
	with standard deviation of 1.9e-06 seconds,
	minimum 8.9e-06, maximum 1.5e-05.
	Total time spent was about 2.5e-04 seconds.
Relative load is estimated to 1.0.

Bunda muhim maʼlumot har biri taxminan 8,5120000000022E-9 soniya davom etgan. Bu funksiya aslida qancha vaqt ishlashini bildiradi.

Eʼtibor bering, bu funktsiya juda oddiy va shuning uchun funktsiyaning ishlash vaqti asosiy ish vaqtiga yaqinlashadi. Natijada, har bir toʻplam uchun ishlash vaqti standart ogʻishlarga yaqinlashadi.

---

-- module timing individual functions
-- @license (CC-BY-SA-3.0)
-- @copyright John Erling Blad <jeblad@gmail.com>

-- @var The table holding this modules exported members
local p = {
	['_count'] = 100,
	['_sets'] = 10,
}

-- access function for the number of items in each sets
-- @param number new count of items in each set
-- @return number of items in each set
function p.count( num )
	if num then
		assert(num>0, "Value of 'num' can\'t be zero")
		p._count = num
	end
	return p._count
end

-- access function for the number of sets
-- @param number new count of sets
-- @return number of sets
function p.sets( num )
	if num then
		assert(num>0, "Value of 'sets' can\'t be zero")
		p._sets = num
	end
	return p._sets
end

-- calculate the statistics for time series, and report mean and variance
-- for some background on this calculation, see [[w:en:average]] and [[w:en:Standard deviation]]
-- @param table timing is a sequence of time differences
-- @return table of mean and variance
function p.stats( timing )
	local minVal = timing[1]
	local maxVal = timing[1]
	local sqr,mean=0,0
	for i,v in ipairs(timing) do
		minVal = v < minVal and v or minVal
		maxVal = v > maxVal and v or maxVal
		mean = v + mean
		sqr = math.pow(v,2) + sqr
	end
	mean = mean / #timing
	local var = (sqr / #timing) - math.pow(mean,2)
	return { mean, var, minVal, maxVal }
end

-- runner that iterates a provided function while taking the time for each chunk of iterations
-- @param function func that is the kernel of the iterations
-- @return table of runtime for the given function
function p.runner(func, ...)
	-- measure the function
	local time = {}
	for i=1,p._sets do
		time[i] = os.clock()
		for j=1,p._count do
			func(...)
		end
		time[i] = os.clock() - time[i]
	end
	
	assert(#time>0, "No entries for time measurements")
	
	return time
end

-- combine the measurements into a new form
-- for some background on this calculation, see [[w:en:Sum of normally distributed random variables]]
-- @param table tick stats for the baseline
-- @param table tack stats for the observed function
-- @return table with the combined stats, shifted from variance to standard deviation
function p.combine(tick, tack)
	-- adjust the actual measurement for the baseline
	return { tack[1] - tick[1], math.pow(tack[2] + tick[2], 0.5), tick[3], tick[4] }
end

-- formatter for the result produced by the runner
-- @param table timing as a mean and a standard deviation
-- @return string describing the result
function p.report( timing )
	local messages = {}
	messages['call-result'] = 'Each call was running for about $1 seconds.\n'
	messages['mean-result'] = '\tMean runtime for each set was $1 seconds,\n\twith standard deviation of $2 seconds,\n\tminimum $3, maximum $4.\n'
	messages['overall-result'] = '\tTotal time spent was about $1 seconds.\n'
	messages['load-result'] = 'Relative load is estimated to $1.\n'
	
	local function g( key, ...)
		local msg = mw.message.new( 'timing-' .. key )
		if msg:isBlank() then
			msg = mw.message.newRawMessage( messages[key] )
		end
		return msg
	end
	
	local function f(formatstring, nums)
		local formatted = {}
		for _,v in ipairs(nums) do
			formatted[1+#formatted] = string.format( formatstring, v )
		end
		return formatted
	end
	
	local strings = {
		g('call-result'):numParams(unpack(f('%.1e', timing[1]))):plain(),
		g('mean-result'):numParams(unpack(f('%.1e', timing[2]))):plain(),
		g('overall-result'):numParams(unpack(f('%.1e', timing[3]))):plain(),
		g('load-result'):numParams(unpack(f('%.1f', timing[4]))):plain()
	}
	return table.concat(strings, '')
end

-- a dummy function that is used for a baseline measure
-- @return nil
function p.nop()
	return nil
end

-- metatable for the export
local mt = {
	-- call-form of the table, with arguments as if it were runner()
	-- @paramfunction func that is the kernel of the iterations
	-- @return string describing the result
	__call = function (self, func, ...)
		-- resolve to the same level
		local f1 = p.nop
		local f2 = func
		
		-- start the clock
		local tick = os.clock()
	
		local baseline = self.stats( self.runner(f1, ...) )
		local actual = self.stats( self.runner(f2, ...) )
		
		local combined = self.combine(baseline, actual)
		local tack = os.clock()
		return self.report({{ combined[1] / p._count }, combined, { tack - tick }, {actual[1]/baseline[1]}})
	end
}

-- install the metatable
setmetatable(p, mt)

-- done
return p