A processzor sebessége mennyire van hatással arra, hogy egy kód miként fut le rajta? (bővebben lent)

Gondolom, hogy ebben az esetben (amit mutatni fogok példaként - köszönet SimkoL megoldásáért - ) a magok száma nincs hatással a futási időre, csak a processzor órajele, vagy tévedek?

Például ez a kód i7 processzoron (vagy nagyobb teljesítményűn) hány mp alatt futna le?

Függ attól is, hogy eljárásokra, függvényekre van -e bontva a feladat (mert akkor azokat örökösen hívogatni kell, gondolom ez is idő?)

C nyelven gyorsabban futna az adott kód, vagy mennyire függ ez programozási nyelvtől? Szinte havonta adják ki az újabb és újabb C fordítókat, gondolom hogy processzor-optimalizálást is végeznek ilyenkor?

Én csak Pascal-hoz értek, optimalizálás nélkül 14, optimalizálással 11 mp alatt futott le a kód...

{$OPTIMIZATION REGVAR,LEVEL3}

program project1;

{$mode objfpc}{$H+}

uses {$IFDEF UNIX} {$IFDEF UseCThreads} cthreads, {$ENDIF} {$ENDIF} Classes,sysutils,dateutils;

type

TSS = (start,stop);

var

p: array[1 .. 12] of integer;

is_last: boolean;

n, lepes : longint;

{A későbbi tömbméret változtatás megkönnyítése érdekében a feltöltésnél

és a kiirásnál a Low illetve a High függvényeket használjuk a tömb alsó

és felső indexének eléréséhez}

{Feltölti a p tömböt az alsó és felső indexnek megfelelő értékekkel}

procedure Feltolt;

var i: byte;

begin

for i := Low(p) to High(p) do p[i] := i;

end;

{A paraméterként kapott két értéket megcseréli}

{ procedure Swap(var int_a, int_b: integer);

var int_c: integer;

begin

int_c := int_a;

int_a := int_b;

int_b := int_c;

end;}

{Kiírja a p tömb értékeit}

procedure Kiir;

var i: integer;

begin

for i := Low(p) to High(p) do Write(p[i], ' ');

{ Write(' ', lepes, '. variáció');}

WriteLn;

end;

procedure Next;

var j, m: longint;

c:longint;

begin

is_last := True;

j := n - 1;

{Jobbról megkeressük az első elemet, ami kisebb a nála jobbra állónál.

Ha van ilyen akkor az is_last logikai változót Hamisra állítjuk, jelezve

ezzel, hogy a tömb még nincs csökkenő sorrendbe rendezve, ugyanis ez a

módszer a növekvő jellegű tömbökre érvényes}

while (j > 0) do

begin

if p[j] < p[j + 1] then

begin

is_last := False;

{Ha találtunk a feltételnek megfelelőt kilépünk a ciklusból}

Break;

end;

Dec(j);

end;

{Ha a tömbünk még nincs tökéletes csökkenő formába rendezve, ami az

is_lastváltozó jelez akkor...}

if not is_last then

begin

{Növeljük a variációk számát jelző változót}

Inc(lepes);

{Jobbról megkeressük az első elemet, ami nagyobb, mint az előbb

kiválasztott j indexű elem}

m := n;

while m > j do

begin

{Ha találtunk a feltételnek megfelelőt kilépünk a ciklusból}

if p[m] > p[j] then Break;

Dec(m);

end;

{Megcseréljük a kettőt}

{ Swap(p[m], p[j]);}

c:=p[m];

p[m]:=p[j];

p[j]:=c;

{Megfordítjuk a (j+1)-től a sorozat végéig tartó szakaszt}

m := n;

Inc(j);

while j < m do

begin

{ Swap(p[j], p[m]);}

c:=p[j];

p[j]:=p[m];

p[m]:=c;

Inc(j);

Dec(m);

end;

end;

end;

procedure idomero(ss : TSS; ido : TDateTime);

const StartTime : TDateTime=0;

var dt : integer;

begin

case ss of

start: begin

starttime := ido;

Write('Start...');

end;

stop: begin

dt := MilliSecondsBetween(Ido, StartTime);

Write('Stop ,',dt/1000:7:4,' mp -');

end;

end;

end;

begin

idomero(start,time);

lepes := 1;

Feltolt; {Feltöltjük a p tömböt}

n := Length(p); {n := a p tömb mérete}

{Addig fut a ciklus, amíg a tömb még nincs csökkenő sorrendbe rendezve}

while not is_last do

begin

{ Kiir;}

Next;

end;

{ ReadLn;}

idomero(stop,time);

end.