CPU Benchmark

[Ohne Gehäuse]

Hi,
In diesem Thread moechte ich euch meinen CPU Benchmark vorstellen. Er ist single-threaded. In dem Benchmark muss die CPU die Umlaufbahn von 1000000 Steine um einen Planeten im Weltall berechnen. Da viele Zahlen zufaellig generiert werden variiert die Zeit die der Benchmark braucht um fertig zu werden. Ich plane eine Highscoreliste in diesem Thread und auf meiner Webseite zu veroeffentlichen.

Hier koennt ihr den Benchmark herunterladen:

2shared - download CPU Benchmark (Single-threaded).zip

Bitte postet eure Resultate in diesem Format:

Viel Spass mit dem Benchmark,
thysol

Highscore Liste:

CPU Benchmark (single-threaded) v1.1​

Dieser neue Benchmark braucht laenger zum durchlaufen, damit wird die Genauigkeit erhoeht. Die Genauigkeit habe ich auch mit Tweaks im Code stark erhoeht. Hier koennt ihr den Benchmark herunterladen:

2shared - download CPU Benchmark (Single-threaded) v1.1.zip

Bitte postet wieder in diesem Format:

Highscore Liste:

CPU Benchmark (multi-threaded)​

Hier ist mein neuer multi-threaded CPU Benchmark. Diesmal muss die CPU die Umlaufbahn von 100000000 Steine um einen Planeten berechnen, das ist 100 mal mehr als vorher. Daher braucht der Benchmark jetzt laenger um durchgefuehrt zu werden. Hier koennt ihr euch den Benchmark herunterladen:

2shared - download CPU Benchmark (Multi-threaded).zip

Hier ist mein Resultat, postet bitte wieder in diesem Format:

Highscore Liste:

GPU Benchmark v1.0​

Ich habe jetzt auch einen GPU benchmark mit dem selben Algorithm programmiert. Hier gibt es allerdings einiges zu beachten:

1. Den Benchmark mindestens 2 mal durchlaufen lassen denn im ersten Durchlauf muss OpenCL initialisiert werden. Die daraufolgenden Durchlaeufe sollten aber alle nahezu gleich sein.

2. Der Benchmark kann bei sehr langsamen Grafikkarten zu einem Systemabsturz fuehren! Benutzung des Benchmarks auf eigene Gefahr!

3. Ihr muesste den Benchmark aus dem originalen Ordner heraus ausfuehren. Die Datei, Cloo.dll muss im selben Ordner liegen wie die .exe.

Hier ist der Download Link:

2shared - download GPU benchmark v1.0.zip

Bitte postet eure Resultate in diesem Format:

Highscore Liste:

 

[Abe81]

Kann man ein bisschen mehr zu diesem Bench erfahren?

Meine Werte:

 

[Ohne Gehäuse]

Die Highscore Listen wurden geupdated.

Kann man ein bisschen mehr zu diesem Bench erfahren?

Klar, was willst du wissen?

 

[Abe81]

Sind Intel-Prozessoren in deiner Tabelle blau und AMD grün? Wenn ja, dann bin ich falsch eingefärbt. Ich besitze doch keinen AMD... bäh.

Klar, was willst du wissen?

z.B. wie man darauf kommt, Umlaufbahnen von Steinen berechnen zu lassen und wie das umgesetzt ist. Hast du die Algorithmen aus der Astrophysik geklaut?

 

[xeroftw]

Mhh naja einfach gehalten.

(Ich glaub ich mach dann mal mit OC)

 

[cartridge_case]

Da viele Zahlen zufaellig generiert werden variiert die Zeit die der Benchmark braucht um fertig zu werden.

wie sinnfrei ist das denn? oder habe ich das konzept eines benchmarkes, vergleichbare werte zu bekommen, falsch verstanden?

 

[twilight]

Klar, was willst du wissen?

Für den Anfang mal den verwendeten Compiler sowie Flags, des Weiteren wäre die Sprache und am besten der komplette Source Code interessant. Dann könne man schnell sehen, worauf haupsächlich Wert gelegt wird:

• Integer?
• FP (SP oder DP)?
• Wird vektorisierter Code eingesetzt: SSE, AVX?
• Wie sieht es mit der Größe und Latenz der Caches aus?
• Welchen Einfluss spielt die verfügbare Speicherbandbreite und Latenz?

Nur mal so am Rande kann imho ein "Benchmark" mit einer Laufzeit von nur wenigen Sekunden kaum sinnvolle Resultate erzielen, da z.B. andere Programme oder sogar Hintergundprozesse des OS selbst einen viel zu großen Einfluss nehmen können. Vom Scheduling beim Multithreading oder solche Eigenarten wie SMT will ich gar nicht erst anfangen.

 

[Ohne Gehäuse]

Ich habe dem Startpost einen neuen GPU Benchmark hinzugefuegt.

Sind Intel-Prozessoren in deiner Tabelle blau und AMD grün? Wenn ja, dann bin ich falsch eingefärbt. Ich besitze doch keinen AMD... bäh.

So ist es, sorry, werde ich sobald wie moeglich fixen.

z.B. wie man darauf kommt, Umlaufbahnen von Steinen berechnen zu lassen und wie das umgesetzt ist. Hast du die Algorithmen aus der Astrophysik geklaut?

Ganz einfach, es ist sehr einfach ein Algorithm der die Umlaufbahn von Steinen berechnet zu paralelisieren. Geklaut ist der Algorithm auch nicht, den habe ich von Grund auf selbst programmiert.

wie sinnfrei ist das denn? oder habe ich das konzept eines benchmarkes, vergleichbare werte zu bekommen, falsch verstanden?

Also das problem habe ich eigentlich schon ausgebessert. v1.1 ist viel genauer.

Für den Anfang mal den verwendeten Compiler sowie Flags, des Weiteren wäre die Sprache und am besten der komplette Source Code interessant.

Ich habe die CPU benchmarks in C# programmiert. Den GPU Benchmark habe ich in C# und OpenCL programmiert. Hier ist der Source Code (ohne GUI Code)

CPU Benchmark (Single-threaded) v1.1:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;


namespace CPU_Benchmark__Single_threaded_
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
Random RandomClass = new Random();

int n = 1000000;
int i = 0;
double b;
int z = 0;

double[] v1 = new double[n];
double[] v2 = new double[n];
double[] v3 = new double[n];
double[] v4 = new double[n];
double[] v5 = new double[n];
double[] v6 = new double[n];
double[] v7 = new double[n];
double[] v8 = new double[n];

for (int a = 0; a < n; a++)
{
v1[a] = RandomClass.Next(1000, 100000);
v2[a] = RandomClass.Next(200000, 10000000);
v3[a] = 6378140 + v2[a];
}

sw.Start();
while (z < 40)
{
i = 0;
while (i < n)
{
v4 = v3 / (2 * 398600500000000 / (v3 * (v1 * v1)) - 1);
v5 = v3 * (v1 * v1) / 398600500000000 - 1;
v6 = v4 / (1 + v5);
v7 = v5 * v6;
v6 = v6 * v6;
v7 = v7 * v7;
v8 = v6 - v7;
v8 = Math.Pow(v8, 2);
i++;
}

z++;

}
sw.Stop();
b = sw.Elapsed.TotalSeconds;
label1.Text = b.ToString();
}
}
}

CPU Benchmark (multi-threaded):

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace CPU_Benchmark__Single_threaded_
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

static void orbit(object work)
{
Work w = (Work)(work);
int z = 0;
while (z < 40)
{

for (int i = w.begin; i < w.end; i++)
{
Work.v4 = Work.v3 / (2 * 398600500000000 / (Work.v3 * (Work.v1 * Work.v1)) - 1);
Work.v5 = Work.v3 * (Work.v1 * Work.v1) / 398600500000000 - 1;
Work.v6 = Work.v4 / (1 + Work.v5);
Work.v7 = Work.v5 * Work.v6;
Work.v8 = (Work.v6 * Work.v6) - (Work.v7 * Work.v7);
Work.v8 = (float)Math.Pow(Work.v8, 0.5);
}
z++;
}
}

private void button1_Click(object sender, EventArgs e)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
Random RandomClass = new Random();

int n = 1000000;
Work.v1 = new float[n];
Work.v2 = new float[n];
Work.v3 = new float[n];
Work.v4 = new float[n];
Work.v5 = new float[n];
Work.v6 = new float[n];
Work.v7 = new float[n];
Work.v8 = new float[n];
int cores = Environment.ProcessorCount;
double b;

for (int i = 0; i < n; i++)
{
Work.v1 = RandomClass.Next(1000, 100000);
Work.v2 = RandomClass.Next(200000, 10000000);
Work.v3 = 6378140 + Work.v2;
}
Work[] w = new Work[cores];
int iwork = n / cores;
for (int i = 0; i < cores; i++)
{
w = new Work(i * iwork, (i + 1) * iwork);
}
int round = n % cores;
Thread[] threads = new Thread[cores];

if (round != 0)
{
w[cores - 1].end += round;
}

for (int i = 0; i < cores; i++)
{
threads = new Thread(new ParameterizedThreadStart(orbit));
threads.Priority = ThreadPriority.Normal;
}

sw.Start();

for (int i = 0; i < cores; i++)
{
threads.Start(w);
}

for (int i = 0; i < cores; i++)
{
threads.Join();
}

sw.Stop();
b = sw.Elapsed.TotalSeconds;
label1.Text = b.ToString();
}

class Work
{
public int begin;
public int end;
public static float[] v1;
public static float[] v2;
public static float[] v3;
public static float[] v4;
public static float[] v5;
public static float[] v6;
public static float[] v7;
public static float[] v8;
public Work(int begin, int end)
{
this.begin = begin;
this.end = end;
}
}
}
}

GPU Benchmark v1.0:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using Cloo;

namespace CPU_Benchmark__Single_threaded_
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
Random RandomClass = new Random();
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
double a;

int numPlats = ComputePlatform.Platforms.Count;
ComputeContextPropertyList Properties = new ComputeContextPropertyList(ComputePlatform.Platforms[0]); ComputeContext Context = new ComputeContext(ComputeDeviceTypes.All, Properties, null, IntPtr.Zero);

string vecSum = @"
__kernel void
orbit(__global float * v1,
__global float * v2,
__global float * v3,
__global float * v4,
__global float * v5,
__global float * v6,
__global float * v7,
__global float * v8)
{
int i = get_global_id(0);
int b = 0;

while (b < 1000)
{

v4 = v3 / (2 * 398600500000000 / (v3 * (v1 * v1)) - 1);
v5 = v3 * (v1 * v1) / 398600500000000 - 1;
v6 = v4 / (1 + v5);
v7 = v5 * v6;
v6 = v6 * v6;
v7 = v7 * v7;
v8 = v6 - v7;
v8 = sqrt( v8 );
b++;
}
}";

List<ComputeDevice> Devs = new List<ComputeDevice>();
Devs.Add(ComputePlatform.Platforms[0].Devices[0]);

Devs.Add(ComputePlatform.Platforms[0].Devices[1]);

ComputeProgram prog = null;
try
{
prog = new ComputeProgram(Context, vecSum); prog.Build(Devs, "", null, IntPtr.Zero);

}

catch

{ }

ComputeKernel kernelVecSum = prog.CreateKernel("orbit");


ICollection<ComputeKernel> Kernels = prog.CreateAllKernels();
foreach (ComputeKernel k in Kernels)
{
}

int n = 1000000;

float[] v1 = new float[n], v2 = new float[n], v3 = new float[n], v4 = new float[n], v5 = new float[n], v6 = new float[n], v7 = new float[n], v8 = new float[n];
for (int i = 0; i < n; i++)
{
v1 = RandomClass.Next(1000, 100000);
v2 = RandomClass.Next(200000, 10000000);
v3 = 6378140 + v2;
}

ComputeBuffer<float> bufV1 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v1);
ComputeBuffer<float> bufV2 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v2);
ComputeBuffer<float> bufV3 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v3);
ComputeBuffer<float> bufV4 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v4);
ComputeBuffer<float> bufV5 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v5);
ComputeBuffer<float> bufV6 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v6);
ComputeBuffer<float> bufV7 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v7);
ComputeBuffer<float> bufV8 = new ComputeBuffer<float>(Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, v8);

kernelVecSum.SetMemoryArgument(0, bufV1);
kernelVecSum.SetMemoryArgument(1, bufV2);
kernelVecSum.SetMemoryArgument(2, bufV3);
kernelVecSum.SetMemoryArgument(3, bufV4);
kernelVecSum.SetMemoryArgument(4, bufV5);
kernelVecSum.SetMemoryArgument(5, bufV6);
kernelVecSum.SetMemoryArgument(6, bufV7);
kernelVecSum.SetMemoryArgument(7, bufV8);

ComputeCommandQueue Queue = new ComputeCommandQueue(Context, ComputePlatform.Platforms[0].Devices[0], ComputeCommandQueueFlags.None);

Queue.Execute(kernelVecSum, null, new long[] { v1.Length }, null, null);

v8 = Queue.Read<float>(bufV8, null);

sw.Stop();
a = sw.Elapsed.TotalSeconds;
label1.Text = a.ToString();
}
}
}

 

[Abe81]

Warum stinken die Intel-Quads der ersten Generation eigentlich so ab, trotz kräftiger Übertaktung?

 

[Ohne Gehäuse]

Warum stinken die Intel-Quads der ersten Generation eigentlich so ab, trotz kräftiger Übertaktung?

Weil sie eine schlechte IPC haben.

 

[Somerset]

Finde denn Benchmark wirklich gut! Da hat bei mir gute Werte ausgespuckt.

Ergänzung (2. Juli 2011)

Ich fände es gut wenn er im Highscore auch die Endtemperatur notiren würde. Diese aber kein Kriterium ist.

 

[cartridge_case]

@Notch: coole begründung endtemperatur? bei 0,1s arbeit? o.O

 

[Somerset]

Oh das hbe ich ja ganz vergessen^^

 

[Ohne Gehäuse]

Die Highscore Listen wurden geupdated.

 

[twilight]

Ich werf nochmal ein paar Gedanken zu diesem speziellen Benchmark in die Runde:

C# ist eine für einen Benchmark suboptimale Sprachwahl, da es bei C# Code genau wie z.B. Java Code in erster Linie um Portibility geht. Deswegen bestehen C# Programme aus Intermediate Language Instructions und es werden erst zur Runtime Machine Instructions für die jeweilige Architektur von einem JIT Compiler erzeugt. D.h. du kannst nicht einmal sicherstellen, dass dein Benchmark auf jeden Rechner den selben Code ausführt. Von den möglichen verschiedenen Runtime Environments und deren jeweiligen verschiedenen Versionen fang ich lieber gar nicht erst an. Btw erzeugt ein Port deines Codes nach Java ohne weitere Optimierungen deutlich bessere Ergebnisse, was nicht wirklich für .NET spricht

Der von dir hier präsentierte Code bietet noch einiges an Optimierungspotential: Beispielsweise lässt sich der Speicherverbrauch stark reduzieren und die Expotentialfunktion ist typischerweise für beliebige Basen und Exponenten implementiert und somit für eine einfache Quadrierung ziemlich ineffizient. Wenn du Lust hast, kannst du den Code ja mal kurz nach C oder C++ portieren und ein wenig Profiling betreiben um die Cache Misses ein wenig zu reduzieren.

Desweiteren erschließt sich mir der Sinn des Codes noch nicht so ganz (vorausgesetzt es soll wirklich irgendetwas berechnet werden): Die Schleife über a ist zur Initialisierung und die über i soll auf etwas umständliche Weise etwas berechnen. Allerdings ist soweit ich es in Erinnerung habe, die i Schleife in eine z Schleife verschachtelt, die diese x Mal mit den exakt selben Werten aufruft. Bei den zufälligen Werten, kannst du übrigens dem Zufallsgenerator zum Testen einen Seed übergeben, so dass dieser dann immer die gleicher Folge von Zufallszahlen erzeugt.

Dein OpenCL Code ist nicht vektorisiert oder andersweitig ansatzweise optimiert, wie man an den extrem schlechten Ergebnissen der AMD GPUs erkennen kann. AMD GPUs haben eine wesentlich höhere Rohleistung als ihre NVidia Pendants und müssten diese sowohl in SP als auch DP deutlich schlagen können, wenn man den Code so gestaltet, dass der Compiler daraus effizient VLIW4 oder VLIW5 Intructions erzeugen kann.

 

[Ohne Gehäuse]

C# ist eine für einen Benchmark suboptimale Sprachwahl, da es bei C# Code genau wie z.B. Java Code in erster Linie um Portibility geht. Deswegen bestehen C# Programme aus Intermediate Language Instructions und es werden erst zur Runtime Machine Instructions für die jeweilige Architektur von einem JIT Compiler erzeugt. D.h. du kannst nicht einmal sicherstellen, dass dein Benchmark auf jeden Rechner den selben Code ausführt. Von den möglichen verschiedenen Runtime Environments und deren jeweiligen verschiedenen Versionen fang ich lieber gar nicht erst an. Btw erzeugt ein Port deines Codes nach Java ohne weitere Optimierungen deutlich bessere Ergebnisse, was nicht wirklich für .NET spricht

Ich kann auch eine CPU version des OpenCL Benchmark schreiben.

Der von dir hier präsentierte Code bietet noch einiges an Optimierungspotential: Beispielsweise lässt sich der Speicherverbrauch stark reduzieren und die Expotentialfunktion ist typischerweise für beliebige Basen und Exponenten implementiert und somit für eine einfache Quadrierung ziemlich ineffizient. Wenn du Lust hast, kannst du den Code ja mal kurz nach C oder C++ portieren und ein wenig Profiling betreiben um die Cache Misses ein wenig zu reduzieren.

Ich schreibe einfach den CPU Benchmark auch in OpenCL.

Desweiteren erschließt sich mir der Sinn des Codes noch nicht so ganz (vorausgesetzt es soll wirklich irgendetwas berechnet werden):

Keine Sorge, da wird was wirklich komplexes berechnet. Die Rechenaufgabe habe ich selber geschrieben und nicht einfach irgendwo geklaut. Wenn du mehr davon wissen willst dann sag bescheid. Denn ich beschreibe die komplexe Rechenaufgabe nur auf Anfrage.

Die Schleife über a ist zur Initialisierung und die über i soll auf etwas umständliche Weise etwas berechnen. Allerdings ist soweit ich es in Erinnerung habe, die i Schleife in eine z Schleife verschachtelt, die diese x Mal mit den exakt selben Werten aufruft.

So ist es. Aber wieso ist das umstaendlich. Dann zeig mir doch wie ich das haette besser machen koennen.

Bei den zufälligen Werten, kannst du übrigens dem Zufallsgenerator zum Testen einen Seed übergeben, so dass dieser dann immer die gleicher Folge von Zufallszahlen erzeugt.

Cool, und wie geht das?

Dein OpenCL Code ist nicht vektorisiert oder andersweitig ansatzweise optimiert, wie man an den extrem schlechten Ergebnissen der AMD GPUs erkennen kann. AMD GPUs haben eine wesentlich höhere Rohleistung als ihre NVidia Pendants und müssten diese sowohl in SP als auch DP deutlich schlagen können, wenn man den Code so gestaltet, dass der Compiler daraus effizient VLIW4 oder VLIW5 Intructions erzeugen kann.

Und wie mache ich das?

Vielen Dank fuer die konstruktive Kritik.

 

[Hawk1980]

Hier haste ein paar Ergebnisse zum eintragen. Sieh unten..
Praktisch ist noch etwas mehr machbar, aber man wills ja nicht überteiben.

Du solltes die Tabellen aufteilen. und jeweils Intel und AMD Tabellen anlegen.
Das Gleiche gilt auch für GPUs. Das schafft ein besseren Vergleich.

Unteranderem ist mir aufgefallen das beim GPUtest die Gpu nur zur häflte ausgelastet wird.So kann die Volle Rohleistung nicht entfaltet werden. Dieser Test sollte überarbeitet werden.

Ansonsten isses ein schöner Benchtest

 

[Abe81]

Der GPU-Bench erzeugt bei mir eine Fehlermeldung (siehe Anhang).

Habe die Hinweise 1-3 gelesen und, sofern nötig, befolgt. Dennoch der Fehler.

Der Text lautet:

See the end of this message for details on invoking 
just-in-time (JIT) debugging instead of this dialog box.

************** Exception Text **************
System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.
Parameter name: index
   at System.ThrowHelper.ThrowArgumentOutOfRangeException()
   at System.SZArrayHelper.get_Item[T](Int32 index)
   at System.Collections.ObjectModel.ReadOnlyCollection`1.get_Item(Int32 index)
   at CPU_Benchmark__Single_threaded_.Form1.button1_Click(Object sender, EventArgs e)
   at System.Windows.Forms.Control.OnClick(EventArgs e)
   at System.Windows.Forms.Button.OnClick(EventArgs e)
   at System.Windows.Forms.Button.WndProc(Message& m)
   at System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)
   at System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message& m)
   at System.Windows.Forms.NativeWindow.Callback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)


************** Loaded Assemblies **************
mscorlib
    Assembly Version: 4.0.0.0
    Win32 Version: 4.0.30319.235 (RTMGDR.030319-2300)
    CodeBase: file:///C:/Windows/Microsoft.NET/Framework/v4.0.30319/mscorlib.dll
----------------------------------------
CPU Benchmark (Single-threaded)
    Assembly Version: 1.0.0.0
    Win32 Version: 1.0.0.0
    CodeBase: file:///C:/Users/abe/Desktop/GPU%20benchmark%20v1.0/GPU%20benchmark%20v1.0.exe
----------------------------------------
System.Windows.Forms
    Assembly Version: 4.0.0.0
    Win32 Version: 4.0.30319.235 built by: RTMGDR
    CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Windows.Forms/v4.0_4.0.0.0__b77a5c561934e089/System.Windows.Forms.dll
----------------------------------------
System.Drawing
    Assembly Version: 4.0.0.0
    Win32 Version: 4.0.30319.1 built by: RTMRel
    CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System.Drawing/v4.0_4.0.0.0__b03f5f7f11d50a3a/System.Drawing.dll
----------------------------------------
System
    Assembly Version: 4.0.0.0
    Win32 Version: 4.0.30319.232 built by: RTMGDR
    CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_MSIL/System/v4.0_4.0.0.0__b77a5c561934e089/System.dll
----------------------------------------
Cloo
    Assembly Version: 0.7.1.0
    Win32 Version: 0.7.1
    CodeBase: file:///C:/Users/abe/Desktop/GPU%20benchmark%20v1.0/Cloo.DLL
----------------------------------------

************** JIT Debugging **************
To enable just-in-time (JIT) debugging, the .config file for this
application or computer (machine.config) must have the
jitDebugging value set in the system.windows.forms section.
The application must also be compiled with debugging
enabled.

For example:

<configuration>
    <system.windows.forms jitDebugging="true" />
</configuration>

When JIT debugging is enabled, any unhandled exception
will be sent to the JIT debugger registered on the computer
rather than be handled by this dialog box.

 

[m4rci]

Der GPU-Bench erzeugt bei mir eine Fehlermeldung (siehe Anhang).

Same here, kommt wohl nicht mit der GTX570 klar