[Vergleich] Wie viele Teraflops schafft euer Thinkpad?

[liquidvel]

Hi,
Gleitkommaoperationen pro Sekunde ist ein Massstab fuer die Leistungsfaehigkeit eines Computers. Ein Teraflop (TFLOP) entspricht 1.000.000.000.000 (1 x 10 hoch 12) Gleitkommaoperationen pro Sekunde. Mich wuerde interessieren, wie viel euer Thinkpad schafft. Als Benchmark habe ich ein Pythonprogramm geschrieben, welches eine 4096 * 4096 Matrix multipliziert. Dafuer sind 4096 * 4096 * 2 * 4096 = 137438953472 Multiplikationen notwendig. Wenn ihr Lust habt, lasst das Programm mal bei euch laufen und postet euer Ergebnis. Es ist ein Pyton-Skript, kein kompiliertes Programm. Ihr koennt den Quelltext mit jedem Texteditor oeffnen und selbst pruefen.

Vorraussetzungen:
- Thinkpad mit python3
- numpy installieren: pip install numpy
- Programm im Anhang des Beitrags

Modell: Thinkpad T440p @ Intel i7-4800MQ (8) @ 3.700GHz / NVIDIA GeForce GT 730M / 16GB RAM

Ergebnis: Multi-Core

0.2534135104442134 TFLOP/S
0.24180093346949227 TFLOP/S
0.19926998351748532 TFLOP/S
0.2381431418390541 TFLOP/S
0.25550959060991524 TFLOP/S
0.2548226508215109 TFLOP/S
0.20093625615274374 TFLOP/S
0.21965659695089285 TFLOP/S
0.24542476552593978 TFLOP/S
0.2514123438741789 TFLOP/S

Ergebnis: Single-Core
Laesst sich in numpy mit export OPENBLAS_NUM_THREADS=1 aktivieren

0.0919514719199625 TFLOP/S
0.09022920879853173 TFLOP/S
0.08970330242453747 TFLOP/S
0.09156814705398253 TFLOP/S
0.09160898925519223 TFLOP/S
0.09177839018747995 TFLOP/S
0.09072834765038293 TFLOP/S
0.09102607564774289 TFLOP/S
0.09055558273528554 TFLOP/S
0.09019110439131561 TFLOP/S

 

[ebastler]

Hmm, irgendwie kommt mir der Test spanisch vor - mein T450s mit i5 5200U kommt auf 0.0027irgendwas. Das wäre 1/100 der Score von deinem. Zugegebenermaßen, es boostet nur auf 2.8 GHz, hat aber auch an die 10-15% höhere IPC. Ich würde sagen, Python ist einfach ziemlich unbrauchbare als Benchmark zwischen Geräten, allein schon weil jeder ne andere Version hat.

 

[gerli09]

Will ja nicht schulmeistern, aber Terraflops kann man nicht vergleichen, weil es die nicht gibt. Bei Teraflops wäre das evtl. möglich.

 

[liquidvel]

@ebastler: 1/100 ist schon wenig das stimmt, deine CPU hat aber auch nur 2 Kerne.

@gerli09: Danke, hab's ausgebessert.

 

[ebastler]

@ebastler: 1/100 ist schon wenig das stimmt, deine CPU hat aber auch nur 2 Kerne.

@gerli09: Danke, hab's ausgebessert.

Das Ding läuft - jedenfalls bei mir - auch nur auf einem Thread. Daher macht das wenig aus wie viele Kerne man hätte.

 

[Herr Moehre]

Terraflops klingt nach ThinkPad Weitwurf, das habe ich seit meinem T61 (und das lebt noch) nicht mehr gemacht.
Aber wie schon meine Vorredner sagten, single Threaded ist das echt etwas weit hergeholt.

 

[liquidvel]

@ebastler Bei mir lief das standardmaessig auf allen Cores. Ich musste eine Umgebungsvariable OPENBLAS_NUM_THREADS=1 setzen, jetzt laeuft es nur auf einem. Habe das Ergebnis oben editiert.

 

[ebastler]

0.3385195898302798 TFLOP/S
0.30339724828166403 TFLOP/S
0.2512595127465016 TFLOP/S
0.3665038759253333 TFLOP/S
0.4190211996080458 TFLOP/S
0.4190211996080458 TFLOP/S
0.41774757894491 TFLOP/S
0.4190211996080458 TFLOP/S
0.4405094662591223 TFLOP/S
0.4190211996080458 TFLOP/S

So schaut es auf meinem Server (Ryzen 5 3600) in einer Win10 VM mit 6 Threads aus.

Beitrag automatisch zusammengeführt: 31 Okt. 2022

@ebastler Bei mir lief das standardmaessig auf allen Cores. Ich musste eine Umgebungsvariable OPENBLAS_NUM_THREADS=1 setzen, jetzt laeuft es nur auf einem. Habe das Ergebnis oben editiert.

Hmm, das ist aber immer noch ein Faktor 50 besser als mein Ergebnis
Irgendwas stimmt da nicht bei mir.

 

[liquidvel]

Du hast natuerlich Recht, wenn du sagst, dass es kein zuverlaessiger Benchmark ist. Ich nutze das Programm z.B. auf einem Linux-System. Aber ich finde, es ist eine nette Idee.

 

[bodu]

X230T i5-3320M 12 GiB RAM Win11 22H2

0.026985853813470274 TFLOP/S
0.025718367041915925 TFLOP/S
0.02828544010537192 TFLOP/S
0.02390242669078261 TFLOP/S
0.024777168464395052 TFLOP/S
0.02296390200033368 TFLOP/S
0.02284936882327563 TFLOP/S
0.04677976632811274 TFLOP/S
0.032576191863474366 TFLOP/S
0.025723180511323964 TFLOP/S

 

[iks230]

OPENBLAS_NUM_THREADS=1

Da ich ein Python-Neuling bin: Wo müsste ich die Umgebungsvariable setzen?

 

[liquidvel]

Da ich ein Python-Neuling bin: Wo müsste ich die Umgebungsvariable setzen?

Welches Betriebssystem nutzt du? Bei Linux kannst du es einfach ausfuehren, bevor du das Programm ausfuehrst.

OPENBLAS_NUM_THREADS=1 python3 dein-programmname.py

oder

export OPENBLAS_NUM_THREADS=1
python3 dein-programmname.py

Bei Windows kommt es auch stark drauf an, welches Terminal du nutzt. Bei cmd.exe ist es glaube ich

set OPENBLAS_NUM_THREADS=1

Ansonsten kannst du auch unter "Start" mal nach "Umgebungsvariablen" suchen, dort kannst du welche setzen. Einfach im Internet zu finden.

 

[iks230]

Hmm, das ist aber immer noch ein Faktor 50 besser als mein Ergebnis

Unter Debian 11 Xfce Live hatte ich auch solche Zahlen. Bei Fedora (siehe unten) waren die Zahlen besser als unter Windows.


@liquidvel: Danke. Hatte einen Denkfehler.


Meine Ergebnisse:

System: T480 i7-8650U 32 GB RAM

OS: Win 10 Pro 22H2 64-Bit mit Python 3.11.0

Mit der Umgebungsvariable:

0.06820791735585097 TFLOP/S
0.06371764185074094 TFLOP/S
0.06516783000104905 TFLOP/S
0.06419381292470376 TFLOP/S
0.06717446406249229 TFLOP/S
0.0628148781866254 TFLOP/S
0.06665322670787734 TFLOP/S
0.06371764185074094 TFLOP/S
0.060253815638876405 TFLOP/S
0.0628436001242174 TFLOP/S

Ohne die Umgebungsvariable:

0.24411892268477992 TFLOP/S
0.274877906944 TFLOP/S
0.26687175431486476 TFLOP/S
0.2588304208499189 TFLOP/S
0.26635456099432125 TFLOP/S
0.274877906944 TFLOP/S
0.2588304208499189 TFLOP/S
0.26635456099432125 TFLOP/S
0.28396477989847 TFLOP/S
0.26635456099432125 TFLOP/S

OS: Fedora 36 KDE Live mit Python 3.10.7

Mit der Umgebungsvariable:

0.1184951795899052 TFLOP/S
0.11927355274440213 TFLOP/S
0.11878278114874259 TFLOP/S
0.11754541297312014 TFLOP/S
0.11644119932806886 TFLOP/S
0.11496954948986277 TFLOP/S
0.11339304098720308 TFLOP/S
0.11279410535749125 TFLOP/S
0.11183166500927255 TFLOP/S
0.11085966196440215 TFLOP/S

Ohne die Umgebungsvariable:

0.2856313983902449 TFLOP/S
0.2856465166856754 TFLOP/S
0.28506266695810845 TFLOP/S
0.2852898398022099 TFLOP/S
0.2846799058233554 TFLOP/S
0.28303284513680305 TFLOP/S
0.2841969241618971 TFLOP/S
0.28475873962958925 TFLOP/S
0.28445567870062616 TFLOP/S
0.2863427797766264 TFLOP/S

 

[liquidvel]

Was auffaellt, dass die Performance bei Windows wohl schlechter ist, als unter Linux. Kann natuerlich auch an der Python-Implementierung oder -Version liegen. Es waere vermutlich besser, den Benchmark in C zu schreiben und Core-Pinning zu aktivieren. Dadurch koennte man verhindern, dass das Ergebnis durch Page-Misses und Thread-Scheduling beeinflusst wird. Vielleicht mache ich das noch.

@iks230: Ganz schoen konsistente Multithread-Performance auf dem Fedora-System.

 

[Herr Moehre]

Windows 10 auf meinem L14 mit Ryzen 7 4750U, erscheint mir im Vergleich zum i7-8650U (weiter oben) recht wenig.

0.3137875650045747 TFLOP/S
0.32645832178622924 TFLOP/S
0.3376878463685651 TFLOP/S
0.3524075730050892 TFLOP/S
0.32568472386732283 TFLOP/S
0.3137875650045747 TFLOP/S
0.3145056143523942 TFLOP/S
0.3137875650045747 TFLOP/S
0.3256847238672789 TFLOP/S
0.32645832178622924 TFLOP/S

Mit der Variablen:

0.3256847238672789 TFLOP/S
0.35150627486448366 TFLOP/S
0.3145056143523942 TFLOP/S
0.3137875650045747 TFLOP/S
0.3385195898325074 TFLOP/S
0.3145056143523942 TFLOP/S
0.3137875650045747 TFLOP/S
0.35150627486443253 TFLOP/S
0.3524075730051405 TFLOP/S
0.3385195898325074 TFLOP/S

 

[hikaru]

Aus dem Code:

N = 4096
#[..]
number_of_multiplications = N*N*2*N
flop = number_of_multiplications

Warum ist gerade 2^36 eine FLOP?

Beim Test auf einem i5-3360M unter Debian 11 mit python3-numpy aus dem Debian-Repo (nicht via pip) habe ich mit libatlas3-base als numpy-Backend um ca. Faktor 10 bessere Ergebnisse als mit libblas3. Ähnliches hatte ich vor ein paar Jahren mal auf einem Cubieboard2 gesehen.

X230T i5-3320M 12 GiB RAM Win11 22H2

0.026985853813470274 TFLOP/S
0.025718367041915925 TFLOP/S
0.02828544010537192 TFLOP/S
0.02390242669078261 TFLOP/S
0.024777168464395052 TFLOP/S
0.02296390200033368 TFLOP/S
0.02284936882327563 TFLOP/S
0.04677976632811274 TFLOP/S
0.032576191863474366 TFLOP/S
0.025723180511323964 TFLOP/S

Das passt zu meinen libatlas3-base-Ergebnissen auf vergleichbarer CPU.
Bei mir wurde allerdings sowohl mit libatlas3-base als auch mit libblas3 immer nur ein CPU-Kern genutzt, unabhängig davon, ob, bzw. wie ich OPENBLAS_NUM_THREADS gesetzt hatte.
Bist du sicher, dass bei dir mehrere Kerne genutzt wurden?

Insgesamt scheinen mir die Ivy-Bridge-Single-Core-Werte um ca. Faktor 2 zu niedrig, wenn die FLOP-Berechnung im Script tatsächlich stimmt, und die Tabelle in der Wikipedia ebenfalls. [1]
Allerdings wären dann die Werte für die Haswell- und Coffee-Lake-CPUs realistisch. Macht Numpy ohne AVX2 bzw. FMA irgendetwas Seltsames, das die Performance drückt?

[1] https://en.wikipedia.org/wiki/FLOPS#Computational_performance

 

[liquidvel]

Bei mir wurde allerdings sowohl mit libatlas3-base als auch mit libblas3 immer nur ein CPU-Kern genutzt, unabhängig davon, ob, bzw. wie ich OPENBLAS_NUM_THREADS gesetzt hatte.

Mach mal folgendes:

import numpy as np
np.__config__.show()

Bei mir ist der Output wie folgt und daher muss ich OPENBLAS_NUM_THREADS setzen. Kann sein, dass du was anderes setzen musst.

openblas64__info:
libraries = ['openblas64_', 'openblas64_']
library_dirs = ['/usr/local/lib']
language = c
define_macros = [('HAVE_CBLAS', None), ('BLAS_SYMBOL_SUFFIX', '64_'), ('HAVE_BLAS_ILP64', None)]
runtime_library_dirs = ['/usr/local/lib']

 

[mectst]

Sicher eine schöne Spielerei (für Informatikstudenten, Programmierenthusiasten und Leute, die Spaß an eigenen Listen und Rankings haben), aber Benchmark-Software gibts doch zuhauf und für jede CPUs gibt es Hersteller-Specs mit entsprechenden Angaben. Da kann ich allerdings nicht sagen, ob und wie die wirklich vergleichbar sind.
Ansonsten ist Python nicht so mein Ding und irgendwie widerstrebt es mir, wenn ich zunächst mal eine Software installieren muss, um das Skript laufen zu lassen. Nichtsdestotrotz Hut ab an den Programmierer, dessen Leistung ich nicht schmälern will.
Also wenn man vergleichen will, warum dann nicht lieber doch bei etwas etabliertem bleiben? Da wird sich sicher jemand auskennen und etwas nennen können, dass für alle Systeme verfügbar ist. Zumindest für Windows schlummert irgendwo in den Tiefen des Forums auch ein Thread, wo die Leistungswert von "Cinebench" vergleichen worden sind. Den könnte man sicher auch wieder beleben.
Und ganz generell noch eine Anmerkung: TFlops sind sicher ein greifbarerer Wert als eine Kennzahl aus dem Benchmark-Programm. Man muss aber auch bedenken, dass neben der Mehrkern-CPU auch GPUs in quasi jedem halbwegs aktuellen Rechner stecken, die auch von jedem Betriebssystem und mittlerweile sicher auch vielen Anwendungen fleißig genutzt werden. So gesehen sind die TFlops der CPU wirklich nur eine Spielerei ohne tiefere Aussage für die Praxis.

Grüße Thomas

 

[hikaru]

Mach mal folgendes:

import numpy as np
np.__config__.show()

Bei mir ist der Output wie folgt und daher muss ich OPENBLAS_NUM_THREADS setzen. Kann sein, dass du was anderes setzen musst.

blas_mkl_info:
  NOT AVAILABLE
blis_info:
  NOT AVAILABLE
openblas_info:
  NOT AVAILABLE
atlas_3_10_blas_threads_info:
  NOT AVAILABLE
atlas_3_10_blas_info:
  NOT AVAILABLE
atlas_blas_threads_info:
  NOT AVAILABLE
atlas_blas_info:
  NOT AVAILABLE
accelerate_info:
  NOT AVAILABLE
blas_info:
    libraries = ['blas', 'blas']
    library_dirs = ['/usr/lib/x86_64-linux-gnu']
    include_dirs = ['/usr/local/include', '/usr/include']
    language = c
    define_macros = [('HAVE_CBLAS', None)]
blas_opt_info:
    define_macros = [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)]
    libraries = ['blas', 'blas']
    library_dirs = ['/usr/lib/x86_64-linux-gnu']
    include_dirs = ['/usr/local/include', '/usr/include']
    language = c
lapack_mkl_info:
  NOT AVAILABLE
openblas_lapack_info:
  NOT AVAILABLE
openblas_clapack_info:
  NOT AVAILABLE
flame_info:
  NOT AVAILABLE
atlas_3_10_threads_info:
  NOT AVAILABLE
atlas_3_10_info:
  NOT AVAILABLE
atlas_threads_info:
  NOT AVAILABLE
atlas_info:
  NOT AVAILABLE
lapack_info:
    libraries = ['lapack', 'lapack']
    library_dirs = ['/usr/lib/x86_64-linux-gnu']
    language = f77
lapack_opt_info:
    libraries = ['lapack', 'lapack', 'blas', 'blas']
    library_dirs = ['/usr/lib/x86_64-linux-gnu']
    language = c
    define_macros = [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)]
    include_dirs = ['/usr/local/include', '/usr/include']

Die Ausgabe ist übrigens für lbblas3, libatlas3-base und libopenblas0-openmp identisch.
Mit libopenblas0-openmp wird auf allen vier Threads gerechnet, ich kann aber auch das nicht über OPENBLAS_NUM_THREADS steuern. Hier erhalte ich ca. 68 GFLOPS/s.
Das Ergebnis ist (unabhängig vom Multithreading) also offenbar stark Implementationsabhängig. Debian böte noch einige andere Alternativen an. [1]

Im Grunde hat @mectst recht. Es ist eine nette Spielerei, aber ohne echte Referenz ist das nicht wirklich ein Benchmark. Und je nachdem, welche Aussage man von so einem Benchmark ableiten will, ist ein singulärer Test der FPU auch wenig aussagekräftig. Wenn wir z.B. ältere Atom-CPUs im Test aufnehmen würden, würde dies das Ergebnis verzerren, weil dort eine FPO zwei Taktzyklen braucht statt einer, was das Ergebnis im Vergleich zu einem Integer-, oder I/O-Test verzerrt.


[1] https://packages.debian.org/bullseye/libblas.so.3

 

[ebastler]

Ein 7zip Test Thread wäre mMn ganz interessant - einer der wenigen Benches die ich kenne, der Windows und Linux, x86 und ARM Versionen hat und überall halbwegs sinnvolle Ergebnisse ausspuckt.