Stresstest für die Integer Einheiten der CPU

G

gaussmath

Guest
Stresstest für die Integer Einheiten der CPU

Falls jemand einen Stresstest sucht, der ausschließlich Integer Einheiten abdeckt, hier bitteschön. Einfach mit Doppelklick starten und die Anzahl der Tasks/Threads festlegen, dann mit Enter bestätigen.

Zum selber Kompilieren:
Code:
[COLOR=blue]using System;
[COLOR=blue]using System.Linq;
[COLOR=blue]using System.Threading.Tasks;
 
[COLOR=blue]namespace IntMark
{
    [COLOR=blue]class [COLOR=#2b91af]Program    {
        [COLOR=blue]static [COLOR=blue]void Main([COLOR=blue]string[] args)
        {
            [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"Number of tasks:");
 
            [COLOR=green]// Be careful, no input validation            [COLOR=blue]int numOfTasks = [COLOR=#2b91af]Convert.ToInt32([COLOR=#2b91af]Console.ReadLine());
 
            [COLOR=green]// Generates about 64kb test data            [COLOR=blue]const [COLOR=blue]long length = 8000;
            [COLOR=blue]long[] array = [COLOR=#2b91af]Enumerable.Range(1, ([COLOR=blue]int)length).Select(x => ([COLOR=blue]long)x).ToArray();
 
            [COLOR=blue]for ([COLOR=blue]int i = 0; i < numOfTasks; i++)
            {
                [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"{0}. Task started...", i + 1);
 
                [COLOR=#2b91af]Task.Factory.StartNew(() =>
                {
                    [COLOR=blue]try                    {
                        [COLOR=blue]while ([COLOR=blue]true)
                        {
                            [COLOR=blue]long dotProduct = array.Sum(x => x * x);
 
                            [COLOR=green]// https://www.wolframalpha.com/input/?i=sum(i%5E2,i%3D1..n)                            [COLOR=blue]if (dotProduct != (length * (length + 1) * (2 * length + 1)) / 6)
                            {
                                [COLOR=blue]throw [COLOR=blue]new [COLOR=#2b91af]InvalidOperationException();
                            }
                        }
                    }
                    [COLOR=blue]catch ([COLOR=#2b91af]Exception ex)
                    {
                        [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"Task aborted with exception {0}", ex.Message);
                    }
                });
            }
 
            [COLOR=#2b91af]Console.ReadKey();
        }
    }
}

Version mit dynamischen Lastwechsel hier: Stresstest für die Integer Einheiten der CPU
 

Anhänge

  • IntMark.zip
    2,7 KB · Aufrufe: 90
Zuletzt bearbeitet von einem Moderator:
AW: Stresstest für die Integer Einheiten der CPU

Der Test verursacht mit 16 Threads eine Package Power von 180 Watt auf meinem Threadripper, obwohl nur 8 Kerne + SMT aktiviert sind.
 

Anhänge

  • Screenshot_19.png
    Screenshot_19.png
    214,1 KB · Aufrufe: 373
AW: Stresstest für die Integer Einheiten der CPU

Hast du mal einen Vergleich mit 8 Threads auf 8 Kernen ohne SMT?

Würde mich interessieren, wie stark sich SMT bei Zen auf den Stromverbrauch auswirkt.
Welchen Threadripper hast du eigentlich?
 
AW: Stresstest für die Integer Einheiten der CPU

Kann ich morgen gerne mal testen. Ich habe den 1950X. Der Game Mode ist zur Zeit aktiviert.
 
AW: Stresstest für die Integer Einheiten der CPU

Disassemblier mal den Mist. Der Code macht zu viel Pause in .NET. Gib der CPU richtig Zunder mit wenigstens K&R C übersetzt mit gcc oder nimm wenn Du es kannst direkt Notepad++ und übersetze mit masm.

Den Code kann man nicht wirklich disassemblieren, decompilieren mit .NET Reflector. Ist ein .NET Assembly. Aber der Code nimmt auf jeden Fall nicht Teil auf der Assembly mit 24 KByte Intros. Das ist mal sicher :-)


Nicht das .NET schlecht ist, ich mag das auch in C#. Aber um eine CPU zu stressen, ein bischen Hardware näher bitte. DIe Pipelines nutzen. Die sollen ackern, für die Integer. Reihenweise. Und nicht wie im Stau, ersma Schleifenbildung, die Stack Pointer zugange, die Integers nix zu tun, wenn alle vom Autobahnkreuz nicht Sternförmig abreisen. Die werden im Stau nicht heiss, wie Autos, eher kalt :-) Die for int Schleife macht Autobahn gesperrt, nicht mehr und nicht weniger. Das macht die gehörig oft. Dann noch die while kaskadiert und dann auch noch Exception Handling, sicher ist sicher. Wenn man sowas Kleines programmiert für den Zweck, dann braucht man kein Exception Handling.
Für normale Anwendergesicht (Lamer) Programmierung ist das Lehrbuchmäßig, aber ja, für den Zweck zwar ungeeignet der Code. Programmieren macht Spaß, deswegen gebe ich mir die Mühe, meinen Senf dazu zu geben.


Bei Pinball Dreams war ich in Aalborg Denmark der Taktzyklenoptimierer 1991. Für scrollfreies Ruckeln strebt man Schleifenbildung an. Straight down Code lässt die Pipelines brennen, auch wenn die RAM Preise teuer sind. Fleissarbeit, Schleifenbildung zu vermeiden. Das kostet so dermaßen Zyklen, jedesmal über Stack Pointer Alles zu sichern im RAM. Mehr mit den Registern arbeiten. Ausm RAM so viel es eben geht sequentiell lesen, nicht so viel schreiben.

Ich habe gerade nochmal drüber nachgedacht. Es wird kein Maximum Heat Test, aber weil die meisten Rehner, während Lastwechsel abstürzen, wenn die VCORE auf den Kernen steiler abfällt als die Eiger Nordwand, bevor die SPAWAS nachregeln, ist der Code doch gut, Bau Floating Point Arithmetics mit ein. Du weisst, ein Vorzeichenbit, 7 Bit Exponent und 24 Bit Mantisse. Nimm nicht den Datentyp double, nimm float. Wir haben es mit 32/64 bit Prozessoren zu tun und nicht mit 32/16 Bit Prozessoren. Ich habe mal für 10MB Speicher 1100 Mark bezahlt.

Speicher haben wir genug. Bau ruhig mal ein paar Waitstates ein in den Tasks. Ich teste das dann gerne :-)

Sorry, jetzt habe ich Multihreaded erst gesehen in der for int. Sorry. Ja , wegen den Lastwechseln kann das so einige Computer zum Abstürzen bringen. Ich habe damals in Lattice C Assembler Mnemonics mit eingebaut. Compilercode ist erfahrungsgemäß nicht so dolle.
 
Zuletzt bearbeitet:
AW: Stresstest für die Integer Einheiten der CPU

Klar ist das high Level Code, aber man weiß halt nicht, was der Jitter so zaubert im Hintergrund. Wenn ich den Code mit 16 Tasks laufen lassen bei mir, habe ich eine CPU Auslastung von 97-98% und eine TDP von 180 Watt auf 8 Kernen, was schon ziemlich hoch ist.
 
AW: Stresstest für die Integer Einheiten der CPU

Ja mach gaussmath App, Integer und Fast Floating Point in.NET. Schön Lastwechsel einbauen. Viele, ganz viele User leben mit BSOD mit instabilen Kisten. Ich kenne keinen Stresstest, der Lastwechsel mit eingebaut hat. Prime 95 kann das bisher am Besten. Da schmieren die Computer ab, wenn einmal kurz die Spawas die abreissende Flanke haben in der Stromversorgung zur CPU.
 
AW: Stresstest für die Integer Einheiten der CPU

Das ist mit Lastwechseln ist natürlich eine gute Idee. Wie würdest du das machen? Sleeps oder Cache-RAM Wechsel über die Größe des Arrays?
 
AW: Stresstest für die Integer Einheiten der CPU

Kannste auch eine dritte Option mit einbauen, RAM malloc()en lassen. Die Lastwechsel sind die, die einem zeigen, ob eine Unit stabil ist. Memtest 86+ ist ja geeignet, um RAMS auf wirkliche Defekte zu prüfen, ohne Lastwechsel CPU hat eine Spannung, Rams. Im Grunde nur dazu geeignet, wirkliche RAM Defekte zu finden.

Im Clan waren europaweit Leute mit selbsgebauten Rechnern unterwegs. Zack offline ein Mitstreiter, so schnell wie es geht wieder on. Die Leute ohne Ausbildung denken, die Abstürze liegen an Windows, Bill Gates die Sau. Dabei ist deren Hardware instabil eingestellt.
 
AW: Stresstest für die Integer Einheiten der CPU

Waitstates... Task Resheduling und Semaphoring, Win32 API
Wait(5000); 5 Sekunden default, dann Vollast. Einstellbar in der gaussmath APP :-)

In der gaussmath app einen link einbauen zu nobugz, MS MVP und der Sysinternals Suite.
 
AW: Stresstest für die Integer Einheiten der CPU

Ja bauste auch noch, das Fenster nicht größer als Core Temp, Komplexe Rechnung mit ein, die Controls haste ja in Visual Studio. I=R*J. Komplexe Rechnung nach Gauss.

Scheiss Theologie :-)


So daß die Kinder ihre Rechner instabil eingestellt in den Bluescreen of Death befördern können :-) Stress Integer & FFP gleichzeitig, ein Radio Button oder Listview Select, Start Button:-) Dazu der obligatorische IRQ int 13h auf zei kaskadierten 8529 Interrupt Controllern Haken für die Waitstates zum Lastwechsel, 5000 msec. default. Danach wieder was der Stromzähler an U/min macht -) Spannungsabriss Interval einbauen für die Waitstates. Vollast 10 Minuten default, dann Spannungsabriss für die Kerne, 5 Sekunden, dass die kalt werden und Nachbarn haben die voll stochen, Option einbauen, selektiv die Kerne unabhängig voneinander via Zufallsgenerator unter Vollast zu fahren, während andere Kerne schlafen...

gaussmath stabling app, der aktuelle Name. :-)
 
Zuletzt bearbeitet:
AW: Stresstest für die Integer Einheiten der CPU

Hm, das sind ja schon erweiterte Strategien. Ich arbeite derzeit an einem ausgefeilten Workload Simulator. Da will ich natürlich nicht so vorgreifen. Aber Lastwechsel mit festen Abständen über 5 Sekunden kann ich noch konfigurierbar einbauen.
 
AW: Stresstest für die Integer Einheiten der CPU

Dekliniere die Parameter im main thread, übergib die Parameter definiert für die Tasks in Klammern für die Threads, so benutzen die Threads die Datenregister der CPU, statt far global zurückzurudern um global zu ernten.
 
AW: Stresstest für die Integer Einheiten der CPU

Meinst du so?
Code:
using System;
using System.Linq;
using System.Threading.Tasks;
 
namespace IntMark
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Number of tasks:");

            // Be careful, no input validation
            int numOfTasks = Convert.ToInt32(Console.ReadLine());
            
            const long length = 8000;

            for (int i = 0; i < numOfTasks; i++)
            {
                Console.WriteLine("{0}. Task started...", i + 1);

                Task.Factory.StartNew(() =>
                {
                    // Generates about 64kb test data
                    long[] array = Enumerable.Range(1, (int)length).Select(x => (long)x).ToArray();

                    try
                    {
                        while (true)
                        {
                            long dotProduct = array.Sum(x => x * x);

                            // https://www.wolframalpha.com/input/?i=sum(i%5E2,i%3D1..n)
                            if (dotProduct != (length * (length + 1) * (2 * length + 1)) / 6)
                            {
                                throw new InvalidOperationException();
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Task aborted with exception {0}", ex.Message);
                    }
                });
            }

            Console.ReadKey();
        }
    }
}

Das hatte ich gestern schon getestet. Es ändert nichts.
 
AW: Stresstest für die Integer Einheiten der CPU

ermittel die möglichen threads der cpu automatisch kerne mal 2 mit smt, sonst nur die anzahl der kerne, before the show begins.

nimm den try block raus und

using System.Management; /*( Manamanap Management _;-)*/

hier, helpschool:

How To Get Hardware Information (CPU ID, MainBoard Info, Hard Disk Serial, System Information , ...) - CodeProject

while(!false) ist schneller, wird über die NANDs gegattert. 74HC00. High Speed CMOS. Complementary High Speed Semiconductor.


Conditional branching real mode, x86 und protected mode :-)


ich starte meistens mit void main(void){...}

K&R ANSI C ist int main(void){};


void main(void){}; wird auf einem motorola 68000 mit #$4E75 übersetzt beim SAS C-Compiler, schlanke 2 Byte. Nen bischen Overhead drumherum als ausführbare Datei.

CMOS= Complementary Metal Oxid Semiconductor.

MOSFET = Metal Oxid Field Effect Transistor
 
Zuletzt bearbeitet:
AW: Stresstest für die Integer Einheiten der CPU

So, neuer Ansatz mit einigen Inspirationen von Plasmadampfer. Die Konfiguration wird über eine Datei "params.txt" übernommen. Insgesamt muss "LoadIntervalSeconds" größer als "PauseTimeSeconds" sein. Mit "UseDynamicLoad 0/1" kann man die dynamischen Lastwechsel abschalten/einschalten. Die Auslastung beträgt nun nahezu konstant 99% auf meinem System. Der Datacontext ist größer, so dass Cache + RAM verstärkt ackern müssen. Im Anhang befindet sich die neue Version + Config-Datei.

Code:
NumOfTasks 16
UseDynamicLoad 0
PauseTimeSeconds 5
LoadIntervalSeconds 30

Code:
[COLOR=blue]using System;
[COLOR=blue]using System.Collections.Generic;
[COLOR=blue]using System.IO;
[COLOR=blue]using System.Linq;
[COLOR=blue]using System.Threading;
[COLOR=blue]using System.Threading.Tasks;
 
[COLOR=blue]namespace IntMark
{
    [COLOR=blue]class [COLOR=#2b91af]Program    {
        [COLOR=blue]static [COLOR=#2b91af]ManualResetEvent manualResetEvent = [COLOR=blue]new [COLOR=#2b91af]ManualResetEvent([COLOR=blue]true);
 
        [COLOR=blue]static [COLOR=blue]void Main([COLOR=blue]string[] args)
        {
            [COLOR=green]// Defaults            [COLOR=blue]int numOfTasks = 16;
            [COLOR=blue]bool useDynamicLoad = [COLOR=blue]true;
            [COLOR=blue]int pauseTimeSeconds = 5;
            [COLOR=blue]int loadIntervalSeconds = 30;
 
            [COLOR=blue]try            {
                [COLOR=blue]var settings =
                     ([COLOR=blue]from line [COLOR=blue]in [COLOR=#2b91af]File.ReadAllLines([COLOR=#a31515]"params.txt")
                      [COLOR=blue]let parameters = line.Split([COLOR=#a31515]' ')
                      [COLOR=blue]select [COLOR=blue]new [COLOR=#2b91af]KeyValuePair<[COLOR=blue]string, [COLOR=blue]string>(parameters[0], parameters[1])).ToDictionary(x => x.Key, x => x.Value);
 
                numOfTasks = [COLOR=#2b91af]Convert.ToInt32(settings[[COLOR=#a31515]"NumOfTasks"]);
                useDynamicLoad = [COLOR=#2b91af]Convert.ToInt32(settings[[COLOR=#a31515]"UseDynamicLoad"]) == 1;
                pauseTimeSeconds = [COLOR=#2b91af]Convert.ToInt32(settings[[COLOR=#a31515]"PauseTimeSeconds"]);
                loadIntervalSeconds = [COLOR=#2b91af]Convert.ToInt32(settings[[COLOR=#a31515]"LoadIntervalSeconds"]);
            }
            [COLOR=blue]catch ([COLOR=#2b91af]FileLoadException ex)
            {
                [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"Error while reading parameter from file: {0}", ex.Message);
            }
 
            [COLOR=blue]const [COLOR=blue]long length = 200000;
 
            [COLOR=blue]if (useDynamicLoad)
            {
                [COLOR=blue]var timer = [COLOR=blue]new [COLOR=#2b91af]Timer((e) =>
                {
                    SetResetPause(pauseTimeSeconds);
                }, [COLOR=blue]null, [COLOR=#2b91af]TimeSpan.Zero, [COLOR=#2b91af]TimeSpan.FromSeconds(loadIntervalSeconds));
            }
 
            [COLOR=blue]for ([COLOR=blue]int i = 0; i < numOfTasks; i++)
            {
                [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"{0}. Task started...", i + 1);
 
                [COLOR=#2b91af]Task.Factory.StartNew(() =>
                {
                    [COLOR=blue]long[] array = [COLOR=#2b91af]Enumerable.Range(1, ([COLOR=blue]int)length).Select(x => ([COLOR=blue]long)x).ToArray();
 
                    [COLOR=blue]try                    {
                        [COLOR=blue]while ([COLOR=blue]true)
                        {
                            [COLOR=blue]long dotProduct = array.Sum(x => x * x);
 
                            [COLOR=green]// https://www.wolframalpha.com/input/?i=sum(i%5E2,i%3D1..n)                            [COLOR=blue]if (dotProduct != (length * (length + 1) * (2 * length + 1)) / 6)
                            {
                                [COLOR=blue]throw [COLOR=blue]new [COLOR=#2b91af]InvalidOperationException();
                            }
 
                            manualResetEvent.WaitOne();
                        }
                    }
                    [COLOR=blue]catch ([COLOR=#2b91af]Exception ex)
                    {
                        [COLOR=#2b91af]Console.WriteLine([COLOR=#a31515]"Task aborted with exception {0}", ex.Message);
                    }
                });
            }
 
            [COLOR=#2b91af]Console.ReadKey();
        }
 
        [COLOR=blue]private [COLOR=blue]static [COLOR=blue]void SetResetPause([COLOR=blue]int pauseTimeSeconds)
        {
            manualResetEvent.Reset();
            [COLOR=#2b91af]Thread.Sleep([COLOR=#2b91af]TimeSpan.FromSeconds(pauseTimeSeconds));
            manualResetEvent.Set();
        }
    }
}

Edit: UseDynamicLoad ist default jetzt 0, also abgeschaltet.
 

Anhänge

  • IntMark.zip
    4,5 KB · Aufrufe: 86
Zuletzt bearbeitet von einem Moderator:
AW: Stresstest für die Integer Einheiten der CPU

Hast du mal einen Vergleich mit 8 Threads auf 8 Kernen ohne SMT?

Würde mich interessieren, wie stark sich SMT bei Zen auf den Stromverbrauch auswirkt.
Welchen Threadripper hast du eigentlich?

Es ist kaum zu glauben, aber der Unterschied beträgt gerade mal 10 Watt und das, obwohl ich 8 statt 16 Threads verwende. Was noch hinzu kommt, ist, dass der Browser kaum bedienbar ist, wenn SMT deaktiviert ist und der Test in der neuen Version läuft.

Irgendwie kann ich das nur schwer glauben, gerade weil der Unterschied bei der Performance so hoch ist, aber die Package Power sich kaum unterscheidet.
 
Zurück