Egy program futása jelentősen gyorsabb lehet, ha nem szedem szét függvényekre és eljárásokra a feladatot, hanem a főprogramban írom meg őket?
A függvények és eljárások (ha azokat sokszor meg kell hívni a feladat végrehajtása során) sok futási időt jelenthetnek?
Régebben tapasztaltam ilyet, azért jutott eszembe, hogy komplettebb, összetettebb algoritmusoknál tapasztalt -e valaki ilyet.
Pascal-tapasztalatok érdekelnének, de az is, hogy a többi programozási nyelvben hogy van ez.
Értem, ennél részletesebb válaszra gondoltam. Én konkrétan tapasztaltam, hogy amikor a főprogramba írtam azt, amit az eljárásnak vagy függvénynek kellett volna elvégeznie, jelentősen több volt a futási idő.
Amint az 5-6 eljárást a főprogramban oldottam meg, felgyorsult.
Ez tipikusan egy olyan felvetés/feltevés, amit ki tudsz próbálni.
Szerintem ha lesz is gyorsulás, az olyan minimális, amiért nem éri meg átláthatatlan, összehányt kódot gyártani.
#3 vagyok
Ja, ki is próbáltad, most olvasom. Azért megoszthatnád a futásidőket (különösen a különbségüket) és a kódokat.
Egyrészt biztosan gyorsabb, ha nem kell ugrálni a függvények között. Másrészről viszont mivel csak egy kiíratás is több függvényt hív meg, a kódodból kikerülő hívások számra szinte biztosan elenyészik a keret miatt adódó hívások számához képest.
A másik, hogy ezzel nagyban megnő a fejlesztési idő és sokkal nehezebben olvasható a kód. Ritka az a feladat, ahol ez megtérül.
Teljesen változó az időintervallum, de az eljáráshívásos mindig később fut le, nagyobb darabszámra átírva az "n" konstanst mégjobban kitűnik ez.
Lehet, hogy az FPC 3.0 RC2 alatt már nincs ez a hiba, kioptimalizálták esetleg, de ez nem biztos.
{$OPTIMIZATION REGVAR,LEVEL3} {$R-} {$mode objfpc}{$h+}
program eljaras_eljarasnelkul;
uses SysUtils;
const
n = 99000;
var
tomb, tomb2 : array [0..n] of longint;
i, j, temp : longint;
DT, DT2 : TDateTime;
procedure csere;
begin
temp := tomb[i];
tomb[i] := tomb[j];
tomb[j] := temp;
end;
begin
randomize;
for i := 0 to n do
tomb[i]:=random(2100000000);
tomb2:=tomb;
dt := now;
for i := 0 to n -1 do
begin
for j := i +1 to n do
begin
if tomb[i] > tomb[j] then
begin
temp := tomb[i];
tomb[i] := tomb[j];
tomb[j] := temp;
end;
end;
end;
dt2 := now;
WriteLn('Eljáráshívás nélkül: Eltelt idő: ',(DT2-DT)*24*3600:0:2,' sec');
tomb:=tomb2;
dt := now;
for i := 0 to n -1 do
begin
for j := i+1 to n do
begin
if tomb[i] > tomb[j] then csere;
end;
end;
dt2 := now;
WriteLn('Eljáráshívással: Eltelt idő: ',(DT2-DT)*24*3600:0:2,' sec');
ReadLn;
end.
A függvényhívásoknak nyilván van járulékos költségük, így hosszabb a futásideje egy függvényhívás alkalmazó megoldásnak. De nem jelentősen.
Ha gyorsabb kódot akarsz, akkor nem ilyen gányolós megoldásokon kell gondolkoznod, hanem egy hatékonyabb algoritmust kell keresned.
A buborékrendezés helyett alkalmazz quick sortot és azt már tényleg lehet jelentős sebességkülönbségnek nevezni.
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!