cccl
CCCL 2.6.1
| Leitfaden für Mitwirkende | Entwicklerbehälter | Zwietracht | Godbolt | Github -Projekt | Dokumentation |
|---|
Willkommen in den Cuda Core Compute Libraries (CCCL), in denen unsere Mission es ist, Cuda entzückender zu machen.
Dieses Repository vereint drei essentielle CUDA C ++ - Bibliotheken in einem einzigen, bequemen Repository:
Das Ziel von CCCL ist es, CUDA C ++ -Entwickler Bausteine zur Verfügung zu stellen, die es einfacher machen, einen sicheren und effizienten Code zu schreiben. Wenn Sie diese Bibliotheken zusammenbringen, wird Ihr Entwicklungsprozess gestoppt und Ihre Fähigkeit erweitert, die Leistung von CUDA C ++ zu nutzen. Weitere Informationen zur Entscheidung, diese Projekte zu vereinen, finden Sie in der Ankündigung hier.
Das Konzept für die CUDA Core Compute-Bibliotheken (CCCL) wuchs organisch aus den Projekten der Schub-, CUM- und Libcudacxx-Projekte heraus, die im Laufe der Jahre unabhängig voneinander entwickelt wurden und ein ähnliches Ziel haben: hochwertige, leistungsstarke und leicht zu verwendende C ++-Abstromtaktionen für Cuda-Entwickler bereitzustellen. Natürlich gab es unter den drei Projekten viel Überschneidungen, und es wurde klar, dass die Gemeinschaft besser bedient wird, indem sie in ein einzelnes Repository vereinen.
Thrust ist die C ++ Parallel -Algorithmen -Bibliothek, die die Einführung paralleler Algorithmen in die C ++ - Standardbibliothek inspiriert hat. Die hochrangige Schnittstelle von Thrust verbessert die Programmiererproduktivität erheblich und ermöglicht die Leistungstretrag zwischen GPUs und Multicore-CPUs über konfigurierbare Backends, die die Verwendung mehrerer paralleler Programmierrahmen (wie CUDA, TBB und OpenMP) ermöglichen.
Cub ist eine Cuda-spezifische Bibliothek auf niedrigerer Ebene, die für parallele Speed-of-Light-Algorithmen für alle GPU-Architekturen ausgelegt ist. Zusätzlich zu Gerätetalgorithmen bietet es kooperative Algorithmen wie blockweite Reduktion und warfweite Scan, wodurch Cuda-Kernel-Entwickler Bausteine zur Schaffung von Leuchtengeschwindigkeiten und benutzerdefinierten Kernel bereitgestellt werden.
libcudacxx ist die CUDA C ++ - Standardbibliothek. Es bietet eine Implementierung der C ++ - Standardbibliothek, die sowohl in Host- als auch in Gerätecode funktioniert. Darüber hinaus bietet es Abstraktionen für Cuda-spezifische Hardwarefunktionen wie Synchronisationsprimitive, Cache-Steuerung, Atomik und mehr.
Das Hauptziel von CCCL ist es, eine ähnliche Rolle zu übernehmen, die die Standard-C ++ -Bibliothek für Standard-C ++ ausfüllt: CUDA C ++ -Entwicklern im Allgemeinen, die sich auf die Lösung der wichtigen Probleme konzentrieren können. Die Vereinigung dieser Projekte ist der erste Schritt, um dieses Ziel zu erkennen.
Dies ist ein einfaches Beispiel, das die Verwendung der CCCL -Funktionalität von Schub, Cub und libcudacxx demonstriert.
Es zeigt, wie man Thrust/Cub/libcudacxx verwendet, um einen einfachen parallelen Reduktionskernel zu implementieren. Jeder Threadblock berechnet die Summe einer Teilmenge des Arrays mit cub::BlockReduce . Die Summe jedes Blocks wird dann unter Verwendung eines Atom -Adds über cuda::atomic_ref von libcudacxx auf einen einzelnen Wert reduziert.
Anschließend zeigt es, wie die gleiche Reduktion mit dem Reduzierung des Thrust reduce des Algorithmus durchgeführt werden kann, und vergleicht die Ergebnisse.
Versuchen Sie es mit Godbolt!
# include < thrust/execution_policy.h >
# include < thrust/device_vector.h >
# include < cub/block/block_reduce.cuh >
# include < cuda/atomic >
# include < cuda/cmath >
# include < cuda/std/span >
# include < cstdio >
template < int block_size>
__global__ void reduce (cuda::std::span< int const > data, cuda::std::span< int > result) {
using BlockReduce = cub::BlockReduce< int , block_size>;
__shared__ typename BlockReduce::TempStorage temp_storage;
int const index = threadIdx. x + blockIdx. x * blockDim. x ;
int sum = 0 ;
if ( index < data. size ()) {
sum += data[ index ];
}
sum = BlockReduce (temp_storage). Sum (sum);
if (threadIdx. x == 0 ) {
cuda::atomic_ref< int , cuda::thread_scope_device> atomic_result (result. front ());
atomic_result. fetch_add (sum, cuda::memory_order_relaxed);
}
}
int main () {
// Allocate and initialize input data
int const N = 1000 ;
thrust::device_vector< int > data (N);
thrust::fill (data. begin (), data. end (), 1 );
// Allocate output data
thrust::device_vector< int > kernel_result ( 1 );
// Compute the sum reduction of `data` using a custom kernel
constexpr int block_size = 256 ;
int const num_blocks = cuda::ceil_div (N, block_size);
reduce<block_size><<<num_blocks, block_size>>>(cuda::std::span< int const >( thrust::raw_pointer_cast (data. data ()), data. size ()),
cuda::std::span< int >( thrust::raw_pointer_cast (kernel_result. data ()), 1 ));
auto const err = cudaDeviceSynchronize ();
if (err != cudaSuccess) {
std::cout << " Error: " << cudaGetErrorString (err) << std::endl;
return - 1 ;
}
int const custom_result = kernel_result[ 0 ];
// Compute the same sum reduction using Thrust
int const thrust_result = thrust::reduce (thrust::device, data. begin (), data. end (), 0 );
// Ensure the two solutions are identical
std::printf ( " Custom kernel sum: %d n " , custom_result);
std::printf ( " Thrust reduce sum: %d n " , thrust_result);
assert (kernel_result[ 0 ] == thrust_result);
return 0 ;
}Alles in CCCL ist nur Header. Daher müssen Benutzer sich nur darum kümmern, wie sie die Header -Dateien erhalten und wie sie sie in ihr Build -System einbeziehen.
Der einfachste Weg, um mit CCCL zu beginnen, ist das CUDA -Toolkit, das die CCCL -Header enthält. Wenn Sie mit nvcc kompilieren, fügt es automatisch CCCL -Header zu Ihrem Include -Pfad hinzu, sodass Sie einfach einen CCCL -Header in Ihrem Code ohne zusätzliche Konfiguration #include können.
Wenn Sie mit einem anderen Compiler kompilieren, müssen Sie den Suchpfad Ihres Build -Systems aktualisieren, um auf die CCCL -Header in Ihrer CTK -Installation zu verweisen (z. /usr/local/cuda/include ).
# include < thrust/device_vector.h >
# include < cub/cub.cuh >
# include < cuda/std/atomic > Benutzer, die auf dem neuesten Stand der CCCL -Entwicklung bleiben möchten, werden ermutigt, CCCL von GitHub zu verwenden. Die Verwendung einer neueren Version von CCCL mit einer älteren Version des CUDA -Toolkits wird unterstützt, aber nicht umgekehrt. Vollständige Informationen zur Kompatibilität zwischen CCCL und dem CUDA -Toolkit finden Sie in unserer Plattformunterstützung.
Alles in CCCL ist nur Header, so dass das Klonen und Einbeziehen in ein einfaches Projekt so einfach ist wie die folgenden:
git clone https://github.com/NVIDIA/cccl.git
nvcc -Icccl/thrust -Icccl/libcudacxx/include -Icccl/cub main.cu -o mainHINWEIS Verwenden Sie
-Iund nicht-isystem, um Kollisionen mit den CCCL -Headern zu vermeiden, die vonnvccaus dem CUDA -Toolkit enthalten sind. Alle CCCL -Header verwenden#pragma system_header, um sicherzustellen, dass die Warnungen weiterhin zum Schweigen gebracht werden, als ob es mit-isystemverwendet wird. Weitere Informationen finden Sie in #527.
Ein minimaler Build, der nur Installationsregeln generiert, kann mit der install CMake Preset konfiguriert werden:
git clone https://github.com/NVIDIA/cccl.git
cd cccl
cmake --preset install -DCMAKE_INSTALL_PREFIX=/usr/local/
cd build/install
ninja install Verwenden Sie das install-unstable Verzeichnis, um experimentelle Bibliotheken in die Installation aufzunehmen.
Um nur die experimentellen Bibliotheken zu installieren, verwenden Sie das install-unstable-only und Build-Verzeichnis.
CCCL stellt auch Conda-Pakete jeder Version über den conda-forge -Kanal an:
conda config --add channels conda-forge
conda install cccl Dadurch werden die neuesten CCCL in der $CONDA_PREFIX/include/ und $CONDA_PREFIX/lib/cmake/ Verzeichnisse $ und $ und $ und $ und $ installiert. Es ist durch CMake über find_package(CCCL) erfasst und kann von Compilern in der Conda -Umgebung verwendet werden. Weitere Informationen finden Sie in dieser Einführung in Conda-Forge.
Wenn Sie dieselbe CCCL -Version verwenden möchten, die mit einem bestimmten CUDA -Toolkit, z. B. CUDA 12.4, versandt wird, können Sie CCCL mit:
conda config --add channels conda-forge
conda install cuda-cccl cuda-version=12.4 Die cuda-cccl -Metapackage installiert die cccl Version, die mit dem CUDA-Toolkit versendet wird, das der cuda-version entspricht. Wenn Sie nach der Installation cuda-cccl auf die neueste cccl aktualisieren möchten, können Sie cuda-cccl vor der Aktualisierung cccl deinstallieren:
conda uninstall cuda-cccl
conda install -c conda-forge ccclBeachten Sie, dass es auch Conda-Pakete mit Namen wie
cuda-cccl_linux-64gibt. Diese Pakete enthalten die CCCL -Versionen, die als Teil des CUDA -Toolkits geliefert werden, sind jedoch für den internen Gebrauch durch das CUDA -Toolkit ausgelegt. Installieren Sie stattdessenccclodercuda-cccl, um die Kompatibilität mit Conda-Compilern zu erhalten. Weitere Informationen finden Sie im Rezept CCCL Conda-Forge.
CCCL verwendet CMake für alle Build- und Installationsinfrastrukturen, einschließlich Tests sowie Ziele, mit denen sie in anderen CMake -Projekten verknüpft werden können. Daher ist CMake die empfohlene Möglichkeit, CCCL in ein anderes Projekt zu integrieren.
Ein vollständiges Beispiel dafür, wie dies mit CMAKE -Paket -Manager dies zu tun hat, finden Sie in unserem grundlegenden Beispielprojekt.
Andere Bausysteme sollten funktionieren, aber nur CMake wird getestet. Beiträge zur Vereinfachung der Integration von CCCL in andere Build -Systeme sind willkommen.
Möchten Sie CCCL verbessern? In unserem beitragenden Leitfaden finden Sie einen umfassenden Überblick über alles, was Sie wissen müssen, um Ihre Entwicklungsumgebung einzurichten, Änderungen vorzunehmen, Tests auszuführen und eine PR einzureichen.
Ziel: In diesem Abschnitt wird beschrieben, wo Benutzer erwarten können, dass CCCL erfolgreich kompiliert und ausgeführt wird.
Im Allgemeinen sollte CCCL überall arbeiten, wo das CUDA -Toolkit unterstützt wird. Der Teufel steht jedoch im Detail. In den folgenden Abschnitten werden die Details der Unterstützung und Prüfung für verschiedene Versionen der CUDA -Toolkit-, Host -Compiler- und C ++ - Dialekte beschrieben.
Zusammenfassung:
CCCL -Benutzer werden aufgefordert, die neuesten Verbesserungen und "Live at Head" zu nutzen, indem sie immer die neueste Version von CCCL verwenden. Für eine nahtlose Erfahrung können Sie CCCL unabhängig vom gesamten CUDA -Toolkit aufrüsten. Dies ist möglich, da CCCL mit der neuesten Patch -Veröffentlichung jeder kleinen CTK -Veröffentlichung sowohl aus der aktuellen als auch aus der vorherigen Major -Versionsserie die Rückwärtskompatibilität beibehält. In einigen Ausnahmefällen muss die minimal unterstützte kleinere Version der CUDA -Toolkit -Version möglicherweise neuer sein als die älteste Veröffentlichung innerhalb der Hauptversionserie. Beispielsweise benötigt CCCL eine minimal unterstützte Version von 11,1 aus der 11.x -Serie aufgrund eines unvermeidbaren Compiler -Problems, der in CTK 11.0 vorhanden ist.
Wenn ein neues Major CTK veröffentlicht wird, geben wir die Unterstützung für die älteste unterstützte Major -Version ab.
| CCCL -Version | Unterstützt die CUDA -Toolkit -Version |
|---|---|
| 2.x | 11.1 - 11.8, 12.x (nur neueste Patch -Veröffentlichungen) |
| 3.x (Zukunft) | 12.x, 13.x (nur neueste Patch -Veröffentlichungen) |
Der gut erzogene Code mit dem neuesten CCCL sollte mit jeder unterstützten CTK-Version erfolgreich kompilieren und ausgeführt werden. Ausnahmen können für neue Funktionen auftreten, die von neuen CTK -Funktionen abhängen, sodass diese Funktionen nicht auf älteren Versionen des CTK funktionieren würden. Zum Beispiel wurde C ++ 20 Unterstützung nicht zu CUDA 12.0 zu nvcc hinzugefügt, sodass CCCL -Funktionen, die von C ++ 20 abhängen, nicht mit CTK 11.x.
Benutzer können eine neuere Version von CCCL in einen älteren CTK integrieren, aber nicht umgekehrt. Dies bedeutet, dass eine ältere Version von CCCL nicht mit einem neueren CTK kompatibel ist. Mit anderen Worten, CCCL ist niemals mit dem CUDA -Toolkit kompatibel.
Die folgende Tabelle fasst die Kompatibilität von CTK und CCCL zusammen:
| CTK -Version | Enthalten CCCL -Version | Wünschte CCCL | Unterstützt? | Notizen |
|---|---|---|---|---|
CTK XY | Cccl MAJOR.MINOR | Cccl MAJOR.MINOR+n | ✅ | Einige neue Funktionen funktionieren möglicherweise nicht |
CTK XY | Cccl MAJOR.MINOR | CCCL MAJOR+1.MINOR | ✅ | Mögliche Pausen; Einige neue Funktionen sind möglicherweise nicht verfügbar |
CTK XY | Cccl MAJOR.MINOR | CCCL MAJOR+2.MINOR | CCCL unterstützt nur zwei CTK -Hauptversionen | |
CTK XY | Cccl MAJOR.MINOR | Cccl MAJOR.MINOR-n | CCCL ist nicht vorwärtskompatibel | |
CTK XY | Cccl MAJOR.MINOR | CCCL MAJOR-n.MINOR | CCCL ist nicht vorwärtskompatibel |
Weitere Informationen zur CCCL -Versionierung, der API/ABI -Kompatibilität und der Break -Änderungen finden Sie im Abschnitt "Versioning" unten.
Sofern nicht anders angegeben, unterstützt CCCL alle dieselben Betriebssysteme wie das CUDA -Toolkit, die hier dokumentiert sind:
Sofern nicht anders angegeben, unterstützt CCCL dieselben Host -Compiler wie das neueste CUDA -Toolkit, das hier dokumentiert ist:
Bei der Verwendung älterer CUDA -Toolkits unterstützen wir auch die Host -Compiler des neuesten CUDA -Toolkits, zumindest den neuesten Host -Compiler eines unterstützten älteren Cuda -Toolkits.
Wir können zusätzliche Compiler unterstützen und werden entsprechende Patches der Community mit angemessenen Korrekturen akzeptieren. Wir werden jedoch keine erhebliche Zeit in die Triendätigkeit oder Behebung von Problemen für ältere Compiler investieren.
Im Geiste von "Sie unterstützen nur das, was Sie testen", finden Sie in unserer CI -Übersicht weitere Informationen zu genau dem, was wir testen.
Sofern nicht anders angegeben, unterstützt CCCL die gleichen GPU-Architekturen/Rechenfunktionen wie das CUDA-Toolkit, die hier dokumentiert sind: https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capability
Beachten Sie, dass einige Funktionen möglicherweise nur bestimmte Architekturen/Rechenfunktionen unterstützen.
Die Teststrategie von CCCL weckt ein Gleichgewicht zwischen so vielen Konfigurationen wie möglich und der Aufrechterhaltung angemessener CI -Zeiten.
Bei CUDA -Toolkit -Versionen erfolgt die Tests sowohl gegen die ältesten als auch gegen die neuesten unterstützten Versionen. Wenn beispielsweise die neueste Version des CUDA -Toolkits 12,3 beträgt, werden Tests gegen 11,1 und 12,3 durchgeführt. Für jede CUDA -Version werden Builds gegen alle unterstützten Host -Compiler mit allen unterstützten C ++ - Dialekten abgeschlossen.
Die Teststrategie und die Matrix entwickeln sich ständig weiter. Die in der Datei ci/matrix.yaml definierte Matrix ist die endgültige Quelle der Wahrheit. Weitere Informationen zu unserer CI -Pipeline finden Sie hier.
Ziel: In diesem Abschnitt wird beschrieben, wie CCCL, API/ABI -Stabilitätsgarantien und Kompatibilitätsrichtlinien zur Minimierung von Upgrade -Kopfschmerzen werden.
Zusammenfassung
cub:: oder thrust:: Namespacescuda:: Namespace können jederzeit stattfinden, wird jedoch durch Inkrementierung der ABI -Version widerspiegelt, die in einen Inline -Namespace für alle cuda:: -Symbole eingebettet ist. Mehrere ABI -Versionen können gleichzeitig unterstützt werden.HINWEIS: Vor dem Zusammenführen von Schub, Cub und libcudacxx in dieses Repository wurde jede Bibliothek nach semantischer Versioning unabhängig versioniert. Beginnend mit der Version 2.1 synchronisierten alle drei Bibliotheken ihre Release -Versionen in ihren separaten Repositories. In Zukunft wird CCCL weiterhin unter einer einzelnen semantischen Version veröffentlicht, wobei 2.2.0 die erste Veröffentlichung aus dem NVIDIA/CCCL -Repository ist.
Eine wechselnde Änderung ist eine Änderung der explizit unterstützten Funktionen zwischen veröffentlichten Versionen, bei denen ein Benutzer arbeiten muss, um auf die neuere Version zu aktualisieren.
In der Grenze hat jede Änderung das Potenzial, jemanden irgendwo zu brechen. Infolgedessen gelten nicht alle möglichen Änderungen der Quellenveränderungen als Veränderungen der öffentlichen API, die eine Störung der wichtigsten semantischen Version rechtfertigen.
In den folgenden Abschnitten werden die Details zu Bruchänderungen der API und ABI von CCCL beschrieben.
Die öffentliche API von CCCL ist die gesamte Funktionalität , die absichtlich den Nutzen der Bibliothek bereitstellt.
Mit anderen Worten, die öffentliche API von CCCL geht über die gerechten Funktionssignaturen hinaus und beinhaltet (ist jedoch nicht beschränkt):
Darüber hinaus enthält die öffentliche API von CCCL keine der folgenden:
_ oder __ vorangestellte Symboldetail enthält, einschließlich des detail:: Namespace oder eines Makrosdetail/ Verzeichnis oder Unterabweis enthalten istIm Allgemeinen ist es das Ziel, etwas in der öffentlichen API zu brechen. Solche Änderungen werden nur dann vorgenommen, wenn sie Benutzern eine bessere Leistung, leichter zu verständige APIs und/oder konsistentere APIs bieten.
Bei jeder Veränderung der öffentlichen API werden die Hauptversionsnummer von CCCL gestoßen. In Übereinstimmung mit der Kompatibilität von Cuda Minor -Version werden API -Bruchänderungen und CCCL -Hauptversionen nur mit einer neuen Major -Version des CUDA -Toolkits zusammenfallen.
Alles, was nicht Teil der öffentlichen API ist, kann sich jederzeit ohne Vorwarnung ändern.
Die öffentliche API aller CCCL -Komponenten teilen sich eine einheitliche semantische Version von MAJOR.MINOR.PATCH .
Nur die zuletzt veröffentlichte Version wird unterstützt. In der Regel werden Funktionen und Fehlerbehebungen nicht in die zuvor veröffentlichte Version oder Filialen zurückgeschrieben.
Die bevorzugte Methode zum Abfragen der Version besteht darin, CCCL_[MAJOR/MINOR/PATCH_]VERSION wie unten beschrieben zu verwenden. Für die Rückwärtskompatibilität sind die Definitionen für Thrust/Cub/libcudacxxx verfügbar und stimmen immer mit CCCL_VERSION überein. Beachten Sie, dass Thrust/Cub ein MMMmmmpp -Schema verwenden, während die CCCL und libcudacxx MMMmmmppp verwenden.
| CCCL | libcudacxx | Schub | Jungtier | |
|---|---|---|---|---|
| Kopfball | <cuda/version> | <cuda/std/version> | <thrust/version.h> | <cub/version.h> |
| Hauptversion | CCCL_MAJOR_VERSION | _LIBCUDACXX_CUDA_API_VERSION_MAJOR | THRUST_MAJOR_VERSION | CUB_MAJOR_VERSION |
| Kleinere Version | CCCL_MINOR_VERSION | _LIBCUDACXX_CUDA_API_VERSION_MINOR | THRUST_MINOR_VERSION | CUB_MINOR_VERSION |
| Patch/Subminor -Version | CCCL_PATCH_VERSION | _LIBCUDACXX_CUDA_API_VERSION_PATCH | THRUST_SUBMINOR_VERSION | CUB_SUBMINOR_VERSION |
| Verkettete Version | CCCL_VERSION (MMMmmmppp) | _LIBCUDACXX_CUDA_API_VERSION (MMMmmmppp) | THRUST_VERSION (MMMmmmpp) | CUB_VERSION (MMMmmmpp) |
Die Anwendung Binary Interface (ABI) ist eine Reihe von Regeln für:
Der Abi einer Bibliothek umfasst, ist aber nicht beschränkt auf:
Eine Änderung des ABI -Bruchs ist eine Änderung, die zu einer Änderung des ABI einer Funktion oder einem Typ in der öffentlichen API führt. Beispielsweise ist das Hinzufügen eines neuen Datenmitglieds zu einer Struktur eine ABI -Bruchänderung, da es die Größe des Typs ändert.
In CCCL sind die Garantien über ABI wie folgt:
thrust:: und cub:: Namespaces können ABI jederzeit ohne Vorwarnung brechen.thrust:: und cub:: Symbole enthält die für die Zusammenstellung verwendeten CUDA -Architekturen. Daher kann ein thrust:: oder cub:: Symbol ein anderes ABI haben, wenn:-x cu ) gegen C ++ -Quelle ( -x cpp )cuda:: Namespace können auch jederzeit ABI brechen. cuda:: Symbole betten jedoch eine ABI -Versionsnummer ein, die inkrementiert wird, wenn ein ABI -Bruch auftritt. Mehrere ABI -Versionen können gleichzeitig unterstützt werden. Daher haben Benutzer die Möglichkeit, zu einer vorherigen ABI -Version zurückzukehren. Weitere Informationen finden Sie hier.Wer sollte sich um Abi kümmern?
Im Allgemeinen müssen CCCL -Benutzer sich nur um ABI -Probleme kümmern, wenn Sie ein binäres Artefakt (wie eine gemeinsame Bibliothek) erstellen oder verwenden, dessen API direkt oder indirekt Typen enthält, die von CCCL bereitgestellt werden.
Überlegen Sie sich beispielsweise, ob libA.so mit CCCL Version X erstellt wurde und seine öffentliche API eine Funktion wie:
void foo (cuda::std::optional< int >); Wenn eine andere Bibliothek, libB.so , mit CCCL -Version Y kompiliert wird und foo von libA.so verwendet, kann dies fehlschlagen, wenn zwischen Version X und Y eine ABI -Pause vorhanden ist. Anders als bei API -Bruchänderungen erfordern ABI -Pausen normalerweise keine Codeänderungen und benötigen nur alles, um alles zu verwenden, um dieselbe ABI -Version zu verwenden.
Um mehr über ABI zu erfahren und warum es wichtig ist, sehen Sie, was ABI ist und was C ++ dagegen tun sollte?
Wie oben erwähnt, stellen nicht alle möglichen Änderungen der Quellenveränderungen eine brechensänderte Änderung dar, die die Inkrementierung der API -Hauptversionsnummer von CCCL erfordern würde.
Benutzer werden ermutigt, die folgenden Richtlinien einzuhalten, um das Risiko von Störungen aus versehentlich abhängig von Teilen von CCCL zu minimieren, die nicht Teil der öffentlichen API sind:
thrust:: , cub:: , nv:: oder cuda:: Namespaces cuda::std::iterator_traits es sei dennthrust:: , cub:: , cuda:: oder nv:: Namespaces.thrust:: , cub:: , cuda:: oder nv:: Namespaces._ , __ oder detail Symbol, das überall in seinem Namen vorangestellt ist, einschließlich eines detail:: Namespace oder Makro#include die Header -Datei, die dieses Symbol erklärt, direkt. Mit anderen Worten, verlassen Sie sich nicht auf Header, die von anderen Header implizit eingeschlossen werden.Teile dieses Abschnitts wurden von Abseils Kompatibilitätsrichtlinien inspiriert.
Wir werden unser Bestes tun, um Benutzer zu benachrichtigen, bevor wir Änderungen an der öffentlichen API, ABI oder den unterstützten Plattformen und Compilern ändern.
Entsprechend werden Abschreibungen in Form von programmatischen Warnungen erfolgen, die deaktiviert werden können.
Die Abschaltzeit hängt von den Auswirkungen der Änderung ab, dauert jedoch normalerweise mindestens 2 Moll -Versionen.
Bald kommen!
Eine detaillierte Übersicht über die CI-Pipeline finden Sie in CI-Overview.md.
Projekte, die sich auf die Mission der CCCL beziehen, Cuda entzückender zu machen:
Verwendet Ihr Projekt CCCL? Öffnen Sie eine PR, um Ihr Projekt dieser Liste hinzuzufügen!
