Leistungsindex von Mehrkernprozessoren ermitteln

[Cyberstorm]

hi.

ich habe ein sehr cpu lastiges programm (multi threaded).
ich implementiere gerade eine art netzwerk rendering um die cpu last auf mehrere multi core pc's aufzuteilen.

ich würde nun gerne einen leistungsindex für jede cpu erstellen, der technologien wie "Dynamic Acceleration", "Turbo Boost" etc. berücksichtigt.
ich will quasi wissen welcher rechner wieviel schafft und das unter volllast aller cpu-kerne/threads, da die arbeit vor der eigentlichen berechnung aufgeteilt werden muss.

das problem, welches ich sehe ist, dass die herkömlichen methoden um die cpu geschwindigkeit zu ermitteln alle auf einem thread basieren. und wenn ich nun dies tue und mit TSystemInfo.dwNumberOfProcessors multipliziere denke ich, dass das ergebnis durch oben genannte technologien verfälscht wird, da teilweise automatisch einzelne kerne höher getaktet werden, wenn die anderen idlen. (siehe z.b. http://www.tecchannel.de/pc_mobile/p...ur/index5.html)


lange rede kurze frage: gibt es schon eine entsprechende funktion um den leistungsindex zu ermitteln oder muss ich die selbst programmieren?

oder habe ich einen denkfehler in meiner überlegung?


vielen dank
konrad h.

[mkinzler]

Zudem entsteht ja durch den Overhead der Prozesssynchronisierung weiterer Leistungsverlust. Ein 4-Kern-Prozessor leistet auch ohen Turbo-Boost nicht das 4fache wie ein SingleCore

[gsh]

Außerdem ist nicht jeder Kern einer CPU gleich schnell, bei einer bestimmten Aufgabe. Manche können besser Rechnen (+ -) dafür machen die anderen allgemeinere Sachen besser.
Du kannst niemals alles berücksichtigen, es gibt so viele Prozessor Features.

Deswegen würd ich sagen du lässt alle Computer kurz etwas von der Aufgabe rechnen. Die Zeit die er dafür braucht kannst du als Index verwenden (kleinerer Index - schnellerer Prozessor)

[devidespe]

Man könnte das ab Vista integrierte Systembewertungstool WinSAT verwenden, um die CPU-Geschwindigkeit zu messen:

http://technet.microsoft.com/de-de/l...75(WS.10).aspx

Ich weiss aber nicht, ob es die einzelnen Kerne testet.

[jfheins]

Zitat von gsh:

Außerdem ist nicht jeder Kern einer CPU gleich schnell, bei einer bestimmten Aufgabe. Manche können besser Rechnen (+ -) dafür machen die anderen allgemeinere Sachen besser.

??? Halte ich momentan für Quatsch. Hast du dazu irgendwelche Quellen?
In Zukunft mag das vll. irgendwann passieren (zumal die GPU jetzt ja mit drauf wandert, aber die wird ja noch nicht als CPU Kern behandelt. AMD Bulldozer geht vll. ein wenig in die Richtung ist aber noch nicht draußen) aber noch nicht jetzt.

Zitat:

Deswegen würd ich sagen du lässt alle Computer kurz etwas von der Aufgabe rechnen. Die Zeit die er dafür braucht kannst du als Index verwenden (kleinerer Index - schnellerer Prozessor)

Ist wahrscheinlich das Beste. Wenn's einigermaßen genau sein soll führt daran kein Weg vorbei

[himitsu]

Dann ist ein PC ein dynamisches System ... was du jetzt mißt, das kann in wenigen Minuten ein anderes Ergebnis liefern.

Teile einfach deine Aufgaben in kleinere Teile auf, laß die rechnen und wenn jemand schneller fertig ist, dann holt der sich halt nochein Teil.

[Cyberstorm]

Zitat von jfheins:

Zitat von gsh:

Außerdem ist nicht jeder Kern einer CPU gleich schnell, bei einer bestimmten Aufgabe. Manche können besser Rechnen (+ -) dafür machen die anderen allgemeinere Sachen besser.

??? Halte ich momentan für Quatsch. Hast du dazu irgendwelche Quellen?
In Zukunft mag das vll. irgendwann passieren (zumal die GPU jetzt ja mit drauf wandert, aber die wird ja noch nicht als CPU Kern behandelt. AMD Bulldozer geht vll. ein wenig in die Richtung ist aber noch nicht draußen) aber noch nicht jetzt.

ist definitiv kein quatsch. kann ich aus eigener erfahrung bestätigen. und die unterschiede sind drastisch (teilweise einige prozent). bei meinem quad q6600 z.B. ist kern 3 IMMER der langsamste wenn ich sachen aufteile. falls du es nicht glaubst liefere ich dir in ca. einer stunde eine routine, mit der du das nachvollziehen kannst, in dem mehrere threads gestartet werden und jedem thread per SetThreadAffinityMask ein einzelner kern zugewiesen wird. Dann auslasten und danach lässt sich schön erkennen, welcher kern wieviel geleistet hat.

Zitat von himitsu:

Dann ist ein PC ein dynamisches System ... was du jetzt mißt, das kann in wenigen Minuten ein anderes Ergebnis liefern.

Teile einfach deine Aufgaben in kleinere Teile auf, laß die rechnen und wenn jemand schneller fertig ist, dann holt der sich halt nochein Teil.

das ist richtig, unterscheidet sich meiner meinung nach aber nur minimal und für meine zwecke völlig ausreichend. Das mit dem "wenn fertig, neue aufgabe holen" will ich in meinem fall halt unbedingt vermeiden, da die eigentliche berechnung, wenn ersteinmal gestartet dezentral stattfindet und erst nach erledigen der aufgabe die daten wieder zusammengeführt werden.


wie auch immer, ich schreibe wie gesagt gerade an einer funktion, die soetwas messen soll.
ich werde sie dann hier posten, vielleicht hilft sie anderen leuten als grundgerüst.

viele grüße

[jfheins]

Zitat von Cyberstorm:

ist definitiv kein quatsch. kann ich aus eigener erfahrung bestätigen. und die unterschiede sind drastisch (teilweise einige prozent). bei meinem quad q6600 z.B. ist kern 3 IMMER der langsamste wenn ich sachen aufteile. falls du es nicht glaubst liefere ich dir in ca. einer stunde eine routine, mit der du das nachvollziehen kannst, in dem mehrere threads gestartet werden und jedem thread per SetThreadAffinityMask ein einzelner kern zugewiesen wird. Dann auslasten und danach lässt sich schön erkennen, welcher kern wieviel geleistet hat.

Oha, ja da bin ich sehr dran interessiert - habe auch einen Q6600, hatte aber noch nie das Bedürfnis mir das so genau anzugucken.

[Cyberstorm]

ein memo und ein button brauchts für das beispiel. leider funktioniert die threadzuweisung irgendwie nicht korrekt, wenn man den button mehrfach drückt, jemand eine idee warum?

also wenn ich das programm starte und ein benchmark mache sehe ich das alte phänomen, das cpu-kern 3 bei mir immer der langsamste ist. wenn ich allerdings nochmal den button drück scheint die threadzuweisung nicht mehr hinzuhauen (ist dann nicht mehr nr. 3 der langsamste). wenn ich das programm neustarte ist wieder alles beim alten...

naja hoffe das nützt irgendwem was:

Delphi-Quellcode:

unit main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

  TBenchmarkThread = class(TThread)
    protected
      procedure Execute; override;
    public
      counter, dummy: Integer;
      constructor Create(ThreadNumber: Word); virtual;
  end;

var
  Form1: TForm1;
  BenchmarkThreads: Array of TBenchmarkThread;

implementation

{$R *.dfm}


constructor TBenchmarkThread.Create(ThreadNumber: Word);
begin
  SetThreadPriority(GetCurrentThread, THREAD_PRIORITY_TIME_CRITICAL); //set highest prio
  SetThreadAffinityMask(GetCurrentThread, 1 shl ThreadNumber); //only run on one cpu core (so you can compare the cores..)
  FreeOnTerminate:=True;
  counter:=0;
  inherited Create(True); //create suspended
end;

procedure TBenchmarkThread.Execute;
begin
  while not Terminated do
    begin
      inc(counter);
      dummy:=round(counter / 25); //do some stuff to benchmark
    end;
end;

function GetCPUCount: DWord;
var
  SysInfo: TSystemInfo;
begin
  GetSystemInfo(SysInfo);
  Result:=SysInfo.dwNumberOfProcessors;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  PriorityClass, i: Integer;
  ThreadCount: Word;
  result: integer;
begin
  PriorityClass:=GetPriorityClass(GetCurrentProcess); //save old state
  SetPriorityClass(GetCurrentProcess, REALTIME_PRIORITY_CLASS);
  ThreadCount:=GetCPUCount;
  SetLength(BenchmarkThreads, ThreadCount);
  for i:= 0 to ThreadCount - 1 do BenchmarkThreads[i]:=TBenchmarkThread.Create(i); //create all benchmark threads
  for i:= 0 to ThreadCount - 1 do BenchmarkThreads[i].Start; //start all benchmark threads
  sleep(3000); //wait time can be changed here
  for i:=0 to ThreadCount - 1 do BenchmarkThreads[i].Suspend;
  SetPriorityClass(GetCurrentProcess, PriorityClass); //set old prio
  result:=0;
  for i:=0 to ThreadCount - 1 do
    begin
      memo1.Lines.Add('Thread' + IntToStr(i) + ': ' + IntToStr(BenchmarkThreads[i].counter));
      result:=result + BenchmarkThreads[i].counter;
      BenchmarkThreads[i].Resume;
      BenchmarkThreads[i].Terminate;
    end;
  memo1.Lines.add('--------------------------');
  memo1.lines.add(IntToStr(result));
end;

end.

[gsh]

Zitat von jfheins:

??? Halte ich momentan für Quatsch. Hast du dazu irgendwelche Quellen?
In Zukunft mag das vll. irgendwann passieren (zumal die GPU jetzt ja mit drauf wandert, aber die wird ja noch nicht als CPU Kern behandelt. AMD Bulldozer geht vll. ein wenig in die Richtung ist aber noch nicht draußen) aber noch nicht jetzt.

Quellen hab ich dazu leider keine (würde mich auch genauer interessieren). Hab dies nur auf einer Konfernz erfahren als ich mit einem Firewall Entwickler gesprochen habe.

Aber auf Google findet sich sicher was dazu. Die Frage ist nur mit welchen Suchbegriff