Parallel Thread Execution - Versionsgeschichte

InternetArchiveBot: InternetArchiveBot hat 2 Archivlink(s) ergänzt und 0 Link(s) als defekt/tot markiert.) #IABot (v2.0.9.5

2024-04-11T12:11:56Z

InternetArchiveBot hat 2 Archivlink(s) ergänzt und 0 Link(s) als defekt/tot markiert.) #IABot (v2.0.9.5

← Nächstältere Version		Version vom 11. April 2024, 14:11 Uhr
Zeile 1:		Zeile 1:
	'''Parallel Thread Execution''' ('''PTX''' oder '''NVPTX'''<ref>{{Cite web\|url=https://llvm.org/docs/NVPTXUsage.html\|title=User Guide for NVPTX Back-end — LLVM 7 documentation\|work=llvm.org}}</ref>) ist eine [[Befehlssatzarchitektur]] und [[virtuelle Maschine]] für die Ausführung von [[Parallelrechner\|parallelen]] [[Thread (Informatik)\|Threads]], die in der [[CUDA]]-Programmierung von [[Nvidia]] verwendet wird. Der NVCC-Kompilierer übersetzt Code, der in CUDA, einer C++-ähnlichen Sprache, geschrieben wurde, in PTX-Anweisungen (eine Maschinensprache dargestellt als [[American Standard Code for Information Interchange\|ASCII]]-Text). Der Grafiktreiber enthält einen Kompilierer, der die PTX-Anweisungen in den ausführbaren Binärcode übersetzt<ref>{{Cite web\|url=https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#instruction-set-ref\|title=CUDA Binary Utilities\|date=\|accessdate=2019-10-19\|last=\|first=\|work=docs.nvidia.com\|language=en-us\|archiveurl=\|archivedate=\|url-status=live}}</ref>, der auf den Prozessorkernen der [[Liste der Nvidia-Grafikprozessoren\|Nvidia-GPUs]] ausgeführt werden kann. Die [[GNU Compiler Collection\|GNU-Compiler-Kollektion]] verfügt auch über grundlegende Fähigkeiten zur PTX-Erzeugung im Zusammenhang mit [[OpenMP]].<ref>{{Cite web\|url=https://gcc.gnu.org/wiki/nvptx\|title=nvptx\|work=GCC Wiki}}</ref> Inline-PTX-Assembly kann in CUDA verwendet werden.<ref>{{Cite web\|url=http://docs.nvidia.com/cuda/inline-ptx-assembly/index.html\|title=Inline PTX Assembly in CUDA\|accessdate=2019-11-03\|work=docs.nvidia.com\|language=en-us}}</ref>		'''Parallel Thread Execution''' ('''PTX''' oder '''NVPTX'''<ref>{{Cite web\|url=https://llvm.org/docs/NVPTXUsage.html\|title=User Guide for NVPTX Back-end — LLVM 7 documentation\|work=llvm.org}}</ref>) ist eine [[Befehlssatzarchitektur]] und [[virtuelle Maschine]] für die Ausführung von [[Parallelrechner\|parallelen]] [[Thread (Informatik)\|Threads]], die in der [[CUDA]]-Programmierung von [[Nvidia]] verwendet wird. Der NVCC-Kompilierer übersetzt Code, der in CUDA, einer C++-ähnlichen Sprache, geschrieben wurde, in PTX-Anweisungen (eine Maschinensprache dargestellt als [[American Standard Code for Information Interchange\|ASCII]]-Text). Der Grafiktreiber enthält einen Kompilierer, der die PTX-Anweisungen in den ausführbaren Binärcode übersetzt<ref>{{Cite web\|url=https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#instruction-set-ref\|title=CUDA Binary Utilities\|date=\|accessdate=2019-10-19\|last=\|first=\|work=docs.nvidia.com\|language=en-us\|archiveurl=https://web.archive.org/web/20240101230613/https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#instruction-set-ref\|archivedate=2024-01-01\|url-status=live\|archivebot=2024-04-11 12:11:54 InternetArchiveBot}}</ref>, der auf den Prozessorkernen der [[Liste der Nvidia-Grafikprozessoren\|Nvidia-GPUs]] ausgeführt werden kann. Die [[GNU Compiler Collection\|GNU-Compiler-Kollektion]] verfügt auch über grundlegende Fähigkeiten zur PTX-Erzeugung im Zusammenhang mit [[OpenMP]].<ref>{{Cite web\|url=https://gcc.gnu.org/wiki/nvptx\|title=nvptx\|work=GCC Wiki}}</ref> Inline-PTX-Assembly kann in CUDA verwendet werden.<ref>{{Cite web\|url=http://docs.nvidia.com/cuda/inline-ptx-assembly/index.html\|title=Inline PTX Assembly in CUDA\|accessdate=2019-11-03\|work=docs.nvidia.com\|language=en-us}}</ref>

	== Register ==		== Register ==
Zeile 28:		Zeile 28:
	Geteilter Speicher wird in der PTX-Datei wie folgt deklariert:<syntaxhighlight lang="nasm">		Geteilter Speicher wird in der PTX-Datei wie folgt deklariert:<syntaxhighlight lang="nasm">
	.shared .align 8 .b8 pbatch_cache[15744]; // definiere 15.744 Bytes, ausgerichtet an 8-Byte-Grenzen		.shared .align 8 .b8 pbatch_cache[15744]; // definiere 15.744 Bytes, ausgerichtet an 8-Byte-Grenzen
	</syntaxhighlight>Das Schreiben von Kerneln in PTX erfordert die explizite Registrierung von PTX-Modulen über die CUDA-Treiber-API, was in der Regel umständlicher ist als die Verwendung der CUDA-Runtime-API und des CUDA-Compilers nvcc von Nvidia. Das GPU Ocelot-Projekt bot eine API zur Registrierung von PTX-Modulen neben CUDA-Runtime-API-Kernelaufrufen, allerdings wird GPU Ocelot nicht mehr aktiv weiterentwickelt.<ref>{{Cite web\|url=https://github.com/gtcasl/gpuocelot\|title=GPUOCelot: A dynamic compilation framework for PTX\|date=\|accessdate=\|last=\|first=\|work=github.com\|archiveurl=\|archivedate=\|url-status=live}}</ref>		</syntaxhighlight>Das Schreiben von Kerneln in PTX erfordert die explizite Registrierung von PTX-Modulen über die CUDA-Treiber-API, was in der Regel umständlicher ist als die Verwendung der CUDA-Runtime-API und des CUDA-Compilers nvcc von Nvidia. Das GPU Ocelot-Projekt bot eine API zur Registrierung von PTX-Modulen neben CUDA-Runtime-API-Kernelaufrufen, allerdings wird GPU Ocelot nicht mehr aktiv weiterentwickelt.<ref>{{Cite web\|url=https://github.com/gtcasl/gpuocelot\|title=GPUOCelot: A dynamic compilation framework for PTX\|date=\|accessdate=\|last=\|first=\|work=github.com\|archiveurl=https://web.archive.org/web/20230924180041/https://github.com/gtcasl/gpuocelot\|archivedate=2023-09-24\|url-status=live\|archivebot=2024-04-11 12:11:54 InternetArchiveBot}}</ref>

	== Siehe auch ==		== Siehe auch ==

MaxEmanuel: /* Register */ Grammatik

2022-09-16T15:51:32Z

← Nächstältere Version		Version vom 16. September 2022, 17:51 Uhr
Zeile 9:		Zeile 9:
	</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">		</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">
	@%p14 bra $label; // gehe zu $label		@%p14 bra $label; // gehe zu $label
	</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden Typs. Es gibt auch ~~ein~~ Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.		</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden Typs. Es gibt auch eine Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.

	Es gibt ein paar vordefinierte Bezeichner, die Pseudoregister bezeichnen. Unter anderem enthalten <code>%tid, %ntid, %ctaid</code>, und <code>%nctaid</code> Thread-Indizes, Block-Dimensionen, Block-Indizes und Grid-Dimensionen.<ref name="ptx-isa">{{Cite web\|url=http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf\|title=PTX ISA Version 2.3\|publisher=}}</ref>		Es gibt ein paar vordefinierte Bezeichner, die Pseudoregister bezeichnen. Unter anderem enthalten <code>%tid, %ntid, %ctaid</code>, und <code>%nctaid</code> Thread-Indizes, Block-Dimensionen, Block-Indizes und Grid-Dimensionen.<ref name="ptx-isa">{{Cite web\|url=http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf\|title=PTX ISA Version 2.3\|publisher=}}</ref>

MaxEmanuel: /* Register */ Grammatik

2022-09-16T15:50:52Z

← Nächstältere Version		Version vom 16. September 2022, 17:50 Uhr
Zeile 2:		Zeile 2:

	== Register ==		== Register ==
	PTX verwendet einen beliebig großen Registersatz; die Ausgabe des Compilers erfolgt fast ausschließlich in Form von Einzelzuweisungen, wobei sich aufeinanderfolgende Zeilen im Allgemeinen auf aufeinanderfolgende Register beziehen. Programme beginnen mit Deklarationen der Form<syntaxhighlight lang="asm">		PTX verwendet einen beliebig großen Registersatz; die Ausgabe des Compilers erfolgt fast ausschließlich in Form von Einzelzuweisungen, wobei sich aufeinanderfolgende Zeilen im Allgemeinen auf aufeinanderfolgende Register beziehen. Programme beginnen mit Deklarationen der Form<syntaxhighlight lang="asm">
	.reg .u32 %r<335>; // deklariere 335 Register %r0, %r1, ..., %r334 vom Typ vorzeichenlosem 32-Bit Integer		.reg .u32 %r<335>; // deklariere 335 Register %r0, %r1, ..., %r334 vom Typ vorzeichenlosem 32-Bit Integer
	</syntaxhighlight>Es handelt sich um eine Assemblersprache mit drei Argumenten. Fast alle Befehle geben ausdrücklich den Datentyp (in Form von Vorzeichen und Breite) an, mit dem sie arbeiten. Registernamen wird ein %-Zeichen vorangestellt und Konstanten sind Literale z. B.:<syntaxhighlight lang="asm">		</syntaxhighlight>Es handelt sich um eine Assemblersprache mit drei Argumenten. Fast alle Befehle geben ausdrücklich den Datentyp (in Form von Vorzeichen und Breite) an, mit dem sie arbeiten. Registernamen wird ein %-Zeichen vorangestellt und Konstanten sind Literale z. B.:<syntaxhighlight lang="asm">
	shr.u64 %rd14, %rd12, 32; // schiebe einen ~~vorzeichenlose~~ 64-Bit Integer aus %rd12 nach rechts um 32 Positionen, Ergebnis in %rd14		shr.u64 %rd14, %rd12, 32; // schiebe einen vorzeichenlosen 64-Bit Integer aus %rd12 nach rechts um 32 Positionen, Ergebnis in %rd14
	cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit		cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit
	</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">		</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">
	@%p14 bra $label; // gehe zu $label		@%p14 bra $label; // gehe zu $label
	</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden ~~Types~~. Es gibt auch ~~einen~~ Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.		</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden Typs. Es gibt auch ein Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.

	Es gibt ein paar vordefinierte Bezeichner, die Pseudoregister bezeichnen. Unter anderem enthalten <code>%tid, %ntid, %ctaid</code>, und <code>%nctaid</code> Thread-Indizes, Block-Dimensionen, Block-Indizes und Grid-Dimensionen.<ref name="ptx-isa">{{Cite web\|url=http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf\|title=PTX ISA Version 2.3\|publisher=}}</ref>		Es gibt ein paar vordefinierte Bezeichner, die Pseudoregister bezeichnen. Unter anderem enthalten <code>%tid, %ntid, %ctaid</code>, und <code>%nctaid</code> Thread-Indizes, Block-Dimensionen, Block-Indizes und Grid-Dimensionen.<ref name="ptx-isa">{{Cite web\|url=http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf\|title=PTX ISA Version 2.3\|publisher=}}</ref>

Crazy1880: ref-TAG-fix

2022-08-01T04:53:42Z

ref-TAG-fix

← Nächstältere Version		Version vom 1. August 2022, 06:53 Uhr
Zeile 40:		Zeile 40:

	== Einzelnachweise ==		== Einzelnachweise ==
			<references />

	[[Kategorie:Nvidia]]		[[Kategorie:Nvidia]]

Aka: Abkürzung korrigiert

2022-07-31T19:37:44Z

Abkürzung korrigiert

← Nächstältere Version		Version vom 31. Juli 2022, 21:37 Uhr
Zeile 4:		Zeile 4:
	PTX verwendet einen beliebig großen Registersatz; die Ausgabe des Compilers erfolgt fast ausschließlich in Form von Einzelzuweisungen, wobei sich aufeinanderfolgende Zeilen im Allgemeinen auf aufeinanderfolgende Register beziehen. Programme beginnen mit Deklarationen der Form<syntaxhighlight lang="asm">		PTX verwendet einen beliebig großen Registersatz; die Ausgabe des Compilers erfolgt fast ausschließlich in Form von Einzelzuweisungen, wobei sich aufeinanderfolgende Zeilen im Allgemeinen auf aufeinanderfolgende Register beziehen. Programme beginnen mit Deklarationen der Form<syntaxhighlight lang="asm">
	.reg .u32 %r<335>; // deklariere 335 Register %r0, %r1, ..., %r334 vom Typ vorzeichenlosem 32-Bit Integer		.reg .u32 %r<335>; // deklariere 335 Register %r0, %r1, ..., %r334 vom Typ vorzeichenlosem 32-Bit Integer
	</syntaxhighlight>Es handelt sich um eine Assemblersprache mit drei Argumenten. Fast alle Befehle geben ausdrücklich den Datentyp (in Form von Vorzeichen und Breite) an, mit dem sie arbeiten. Registernamen wird ein %-Zeichen vorangestellt und Konstanten sind Literale z.B.:<syntaxhighlight lang="asm">		</syntaxhighlight>Es handelt sich um eine Assemblersprache mit drei Argumenten. Fast alle Befehle geben ausdrücklich den Datentyp (in Form von Vorzeichen und Breite) an, mit dem sie arbeiten. Registernamen wird ein %-Zeichen vorangestellt und Konstanten sind Literale z. B.:<syntaxhighlight lang="asm">
	shr.u64 %rd14, %rd12, 32; // schiebe einen vorzeichenlose 64-Bit Integer aus %rd12 nach rechts um 32 Positionen, Ergebnis in %rd14		shr.u64 %rd14, %rd12, 32; // schiebe einen vorzeichenlose 64-Bit Integer aus %rd12 nach rechts um 32 Positionen, Ergebnis in %rd14
	cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit		cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit
Zeile 14:		Zeile 14:

	== Zustandsbereiche ==		== Zustandsbereiche ==
	Die Befehle Laden (<code>ld</code>) und Speichern (<code>st</code>) beziehen sich auf einen von mehreren verschiedenen Zustandsbereichen, z.B. <code>ld.param</code>.		Die Befehle Laden (<code>ld</code>) und Speichern (<code>st</code>) beziehen sich auf einen von mehreren verschiedenen Zustandsbereichen, z. B. <code>ld.param</code>.
	Es gibt acht Zustandsbereiche:<ref name="ptx-isa"></ref>		Es gibt acht Zustandsbereiche:<ref name="ptx-isa"></ref>

Chewbacca2205: 65 Versionen von :en:Parallel_Thread_Execution importiert: WP:IMP * user:Luke081515Bot

2022-07-31T17:28:06Z

65 Versionen von en:Parallel_Thread_Execution importiert: WP:IMP * user:Luke081515Bot

← Nächstältere Version	Version vom 31. Juli 2022, 19:28 Uhr
(kein Unterschied)

MaxEmanuel: ref Fehler korrigiert

2022-07-31T16:49:21Z

ref Fehler korrigiert

← Nächstältere Version		Version vom 31. Juli 2022, 18:49 Uhr
Zeile 8:		Zeile 8:
	cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit		cvt.u64.u32 %rd142, %r112; // konvertiere einen vorzeichenlosen 32-Bit Integer zu 64-Bit
	</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">		</syntaxhighlight>Es gibt Prädikatsregister, aber kompilierter Code im Shader-Modell 1.0 verwendet diese nur in Verbindung mit Verzweigungsbefehlen; die bedingte Verzweigung ist<syntaxhighlight lang="asm">
	@%p14 bra $label; // gehe zu $label		@%p14 bra $label; // gehe zu $label
	</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden Types. Es gibt auch einen Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.		</syntaxhighlight>Die Anweisung <code>setp.cc.type</code> setzt ein Prädikatsregister auf das Ergebnis des Vergleichs zweier Register des entsprechenden Types. Es gibt auch einen Anweisung <code>set</code>, wobei <syntaxhighlight lang="asm" inline="">set.le.u32.u64 %r101, %rd12, %rd28</syntaxhighlight> das 32-Bit-Register <code>%r101</code> zu <code>0xffffffff</code> setzt, wenn das 64-Bit-Register <code>%rd12</code> kleiner oder gleich dem 64-Bit-Register <code>%rd28</code> ist. Andernfalls wird <code>%r101</code> zu <code>0x00000000</code> gesetzt.

Zeile 15:		Zeile 15:
	== Zustandsbereiche ==		== Zustandsbereiche ==
	Die Befehle Laden (<code>ld</code>) und Speichern (<code>st</code>) beziehen sich auf einen von mehreren verschiedenen Zustandsbereichen, z.B. <code>ld.param</code>.		Die Befehle Laden (<code>ld</code>) und Speichern (<code>st</code>) beziehen sich auf einen von mehreren verschiedenen Zustandsbereichen, z.B. <code>ld.param</code>.
			Es gibt acht Zustandsbereiche:<ref name="ptx-isa"></ref>
	Es gibt acht Zustandsbereiche:<ref name="ptx-isa">{{Cite web\|url=http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf\|title=PTX ISA Version 2.3\|publisher=}}<cite class="citation web cs1" data-ve-ignore="true">[http://developer.download.nvidia.com/compute/cuda/3_1/toolkit/docs/ptx_isa_2.3.pdf "PTX ISA Version 2.3"] <span class="cs1-format">(PDF)</span>.</cite></ref>

	* <code>.reg</code> : Register		* <code>.reg</code> : Register
Zeile 34:		Zeile 34:
	* Standard Portable Intermediate Representation (SPIR)		* Standard Portable Intermediate Representation (SPIR)
	* [[Fat Binary\|CUDA binary]] (cubin) – a type of fat binary		* [[Fat Binary\|CUDA binary]] (cubin) – a type of fat binary

⚫	== Einzelnachweise ==

	== Weblinks ==		== Weblinks ==

	* [https://docs.nvidia.com/cuda/parallel-thread-execution/ PTX ISA bei NVIDIA Developer Zone]		* [https://docs.nvidia.com/cuda/parallel-thread-execution/ PTX ISA bei NVIDIA Developer Zone]

		⚫	== Einzelnachweise ==
	[[Kategorie:Nvidia]]		[[Kategorie:Nvidia]]

MaxEmanuel: Erstellt durch Übersetzen der Seite „Parallel Thread Execution“

2022-07-31T16:47:07Z

Erstellt durch Übersetzen der Seite „Parallel Thread Execution“

Änderungen zeigen

en>Matthiaspaul: CE

2022-05-26T13:40:21Z

← Nächstältere Version		Version vom 26. Mai 2022, 15:40 Uhr
Zeile 1:		Zeile 1:
	{{Primary sources\|date=August 2020}}		{{Primary sources\|date=August 2020}}
	{{short description\|Low-level parallel thread execution virtual machine and instruction set architecture}}		{{short description\|Low-level parallel thread execution virtual machine and instruction set architecture}}
	'''Parallel Thread Execution''' ('''PTX''' or '''NVPTX'''<ref>{{cite web\|url=https://llvm.org/docs/NVPTXUsage.html\|title=User Guide for NVPTX Back-end — LLVM 7 documentation\|website=llvm.org}}</ref>) is a low-level [[Parallel computing\|parallel]] [[Thread (computing)\|thread]] [[Execution (computing)\|execution]] [[virtual machine]] and [[instruction set architecture]] used in [[Nvidia]]'s [[CUDA]] programming environment. The [[Nvidia CUDA Compiler\|NVCC]] compiler translates code written in CUDA, a [[C++ (programming language)\|C++]]-like language, into PTX instructions, and the graphics driver contains a compiler which translates the PTX instructions into a binary code<ref>{{Cite web\|url=https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#instruction-set-ref\|title=CUDA Binary Utilities\|last=\|first=\|date=\|website=docs.nvidia.com\|language=en-us\|url-status=live\|archive-url=\|archive-date=\|access-date=2019-10-19}}</ref> which can be run on the processing cores of [[List of Nvidia graphics processing units\|Nvidia GPUs]]. The [[GNU Compiler Collection]] also has basic ability for PTX generation in the context of [[OpenMP]] offloading.<ref>{{cite web \|title=nvptx \|url=https://gcc.gnu.org/wiki/nvptx \|website=GCC Wiki}}</ref> Inline PTX assembly can be used in CUDA.<ref>{{Cite web\|url=http://docs.nvidia.com/cuda/inline-ptx-assembly/index.html\|title=Inline PTX Assembly in CUDA\|website=docs.nvidia.com\|language=en-us\|access-date=2019-11-03}}</ref>		'''Parallel Thread Execution''' ('''PTX''' or '''NVPTX'''<ref>{{cite web\|url=https://llvm.org/docs/NVPTXUsage.html\|title=User Guide for NVPTX Back-end — LLVM 7 documentation\|website=llvm.org}}</ref>) is a low-level [[Parallel computing\|parallel]] [[Thread (computing)\|thread]] [[Execution (computing)\|execution]] [[virtual machine]] and [[instruction set architecture]] used in [[Nvidia]]'s [[CUDA]] programming environment. The [[Nvidia CUDA Compiler\|NVCC]] compiler translates code written in CUDA, a [[C++ (programming language)\|C++]]-like language, into PTX instructions (an [[assembly language]] represented as [[ASCII]] text), and the graphics driver contains a compiler which translates the PTX instructions into the executable binary code<ref>{{Cite web\|url=https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html#instruction-set-ref\|title=CUDA Binary Utilities\|last=\|first=\|date=\|website=docs.nvidia.com\|language=en-us\|url-status=live\|archive-url=\|archive-date=\|access-date=2019-10-19}}</ref> which can be run on the processing cores of [[List of Nvidia graphics processing units\|Nvidia GPUs]]. The [[GNU Compiler Collection]] also has basic ability for PTX generation in the context of [[OpenMP]] offloading.<ref>{{cite web \|title=nvptx \|url=https://gcc.gnu.org/wiki/nvptx \|website=GCC Wiki}}</ref> Inline PTX assembly can be used in CUDA.<ref>{{Cite web\|url=http://docs.nvidia.com/cuda/inline-ptx-assembly/index.html\|title=Inline PTX Assembly in CUDA\|website=docs.nvidia.com\|language=en-us\|access-date=2019-11-03}}</ref>

	== Registers ==		== Registers ==

en>Matthiaspaul: /* See also */ improved link

2022-05-25T01:15:31Z

← Nächstältere Version		Version vom 25. Mai 2022, 03:15 Uhr
Zeile 48:		Zeile 48:
	==See also==		==See also==
	* [[Standard Portable Intermediate Representation]] (SPIR)		* [[Standard Portable Intermediate Representation]] (SPIR)
	* [[~~Fat~~ binary]]		* [[CUDA binary]] (cubin) – a type of fat binary

	== References ==		== References ==