Verwenden von Vektortypen gegen benutzerdefinierte Strukturen für 256-Bit-Zahlen in CUDA ⇐ C++

[Anonymous]

Ich arbeite an der Implementierung von 256-Bit-Zahl-Arithmetik in CUDA für Operationen wie Addition mit Tragverbreitung, Subtraktion mit Ausleihen und Vergleich. Anfangs habe ich eine benutzerdefinierte Struktur definiert, um die 256-Bit-Zahl darzustellen: < /p>

Code: Select all

struct big_number_t {
unsigned long long s0; // Least significant limb
unsigned long long s1;
unsigned long long s2;
unsigned long long s3; // Most significant limb
};
< /code>
Ich bin jedoch auf Verweise auf Vektortypen in CUDA gestoßen und stellte fest, dass es integrierte Typen wie Ulong4 und Ulglong4 gibt. (https://docs.nvidia.com/cuda/cuda-cprogramming-guide/index.html#Vector-types-Alignment-Requirements-in-Device-Code) Und ich kann nicht bestimmen, welche dieser dieser Typen korrigiert. Lasten/Speichern im Vergleich zur benutzerdefinierten Struktur? Da die Carry-Ausbreitung sequentiell ist, bin ich mir nicht sicher, ob Vektortypen hier Vorteile bieten. Meine Hauptanliegen sind.struct big_number_t {
unsigned long long s0;
unsigned long long s1;
unsigned long long s2;
unsigned long long s3;
};

__device__ big_number_t bn_add(const big_number_t& a, const big_number_t& b, unsigned long long& carry_out) {
big_number_t result;
unsigned long long carry = 0;

result.s0 = a.s0 + b.s0;
carry = (result.s0 < a.s0) ? 1 : 0;

unsigned long long sum = a.s1 + b.s1 + carry;
carry = (sum < a.s1 || (carry && sum == a.s1)) ? 1 : 0;
result.s1 = sum;

sum = a.s2 + b.s2 + carry;
carry = (sum < a.s2 || (carry && sum == a.s2)) ? 1 : 0;
result.s2 = sum;

sum = a.s3 + b.s3 + carry;
carry = (sum < a.s3 || (carry && sum == a.s3)) ? 1 : 0;
result.s3 = sum;

carry_out = carry;
return result;
}

Würde das Ersetzen von Big_Number_t durch Ulonglong4 oder ulong4 Leistungsvorteile anbieten, oder ist es meistens eine Frage der Präferenz? Danke!