Pascal: eljárásoknál "inline"-t alkalmazva eljáráshívás nem gyorsul, miért?
Fordítói kapcsolót alkalmazom:
{$inline on}
eljárásnév után: inline;
a programban az eljáráshívás nem gyorsul, egy hangyányit se, miért?
Ha a ciklusba írom ami az eljárásban hívom akkor 4x gyorsabb... Rendezésnél csere pl.
Az érdekelne miként lehet megoldani hogy eljáráshívás felgyorsuljon.
Itt a kód.
Nem az érdekelne, miként lehetne a rendezési algoritmust felgyorsítani, hanem az, miként lehetne megoldani a gyorsabb eljáráshívást, amelyet minden programnál tudnék alkalmazni, mert látszólag ez a probléma.
Ha bemásolom a cserét a két ciklusba (és nem eljárásból hívogatom) akkor villámgyors sebességnövekedés tapasztalható...
azt szeretném ha eljárásban is ilyen gyorsan lehetne hívogatni.
{$OPTIMIZATION REGVAR,LEVEL3} {$inline on}
{$MODE FPC} {$H+}
uses SysUtils;
const
meddig = 120000;
var
t : array [1..meddig] of longint;
i, j, cs : longint;
dt,dt2 : TDateTime;
procedure csere;inline;
begin
cs:=t[i];
t[i]:=t[j];
t[j]:=cs;
end;
begin
randomize;
for i:= 1 to meddig do
t[i] := random (MaxLongint);
WriteLn('csere kovetkezik');
dt := now;
for i := 1 to meddig -1 do
begin
for j := i+1 to meddig do
begin
if t[i]<t[j] then
csere;
end;
end;
dt2 := now;
WriteLn('Eltelt ido: ',(DT2-DT)*24*3600:0:2,' sec');
ReadLn;
end.
válasza:Hát akkor valamit nagyon elbaba. Itt az eredmény egy lassú, P4 HT 3 GHz gépen futtatva, a módok Fpc, ObjFpc és Delphi - ezek igazából nem befolyásolnak semmit esetünkben -. A feladat 1..75000 csökkenő sorrendbe rendezése - a random teszt helytelen, mert nem ugyanazt a feladatot kapja meg a program -
Valóban. :-)
Nagyobb elemszám esetén mutatkozik csak különbség, beírtam neki konstansnak:
5*75000
Az eljáráshívás nélküli lefutott kb. 140 mp alatt, a másikat még mindig várom már vagy 5 perce. :S
Hopsz megérkezett, 582 másodperc alatt futott le.
válasza:Hát nem nagyon tudom miket fordítsz. Kód:
program inlin_fpc;
{$OPTIMIZATION REGVAR,LEVEL3}
{$INLINE ON}
{$MODE Fpc}
{$H+}
uses SysUtils;
const meddig = 200000;
var
t: array [1..meddig] of Longint;
i, j, cs: Longint;
dt, dt2: TDateTime;
procedure csere; inline;
begin
cs := t[i];
t[i] := t[j];
t[j] := cs;
end;
procedure csere1;
begin
cs := t[i];
t[i] := t[j];
t[j] := cs;
end;
begin
for i := 1 to meddig do t[i] := i;
WriteLn('Csere kovetkezik - inline -');
dt := now;
for i := 1 to meddig - 1 do
for j := i + 1 to meddig do
if t[i] < t[j] then csere;
dt2 := Now;
WriteLn('Eltelt ido: ', (dt2 - dt) * 24 * 3600: 0: 2, ' sec');
for i := 1 to meddig do t[i] := i;
WriteLn('Csere kovetkezik - inline nelkul -');
dt := Now;
for i := 1 to meddig - 1 do
for j := i + 1 to meddig do
if t[i] < t[j] then csere1;
dt2 := Now;
WriteLn('Eltelt ido: ', (dt2 - dt) * 24 * 3600: 0: 2, ' sec');
for i := 1 to meddig do t[i] := i;
WriteLn('Csere kovetkezik - beepitve -');
dt := Now;
for i := 1 to meddig - 1 do
for j := i + 1 to meddig do
if t[i] < t[j] then
begin
cs := t[i];
t[i] := t[j];
t[j] := cs;
end;
dt2 := Now;
WriteLn('Eltelt ido: ', (dt2 - dt) * 24 * 3600: 0: 2, ' sec');
ReadLn;
end.
Eredmény: [link] a fentebb említett gépen.
Én a következőképp csináltam:
két programot gyártottam, egyiket a {$inline on} kapcsoló bekapcsolásával és az eljárás utáni inline; parancs beírásával fordítottam, másikat pedig simán.
Inline esetén tényleg gyakorlatilag egyazon idő alatt fut le az eljárás és a beágyazott utasítás is.
A "nem inline" program esetén pedig látni lehet, hogy a beágyazott utasítás mennyivel gyorsabban lefut mint a másik esetén tehát az inline az eljárást tényleg gyorsította, de ezzel együtt bizonyos lassulást is okozott.
Ez miért lehet?
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!