Conversion d'un simple code C en code CUDA

Question

J'essaie de convertir un simple code d'analyse numérique (intégration numérique de la règle trapèze) en quelque chose qui fonctionnera sur mon GPU compatible CUDA. Il y a beaucoup de littérature là-bas mais tout semble beaucoup plus complexe que ce qui est requis ici! Mon code actuel est:

#include <stdio.h> 
#include <math.h> 
#include <stdlib.h> 
#define N 1000 

double function(double); 

int main(void) 
{ 
    int i; 
    double lower_bound, upper_bound, h, ans; 

    printf("Please enter the lower and upper bounds: "); 
    scanf(" %lf %lf", &lower_bound, &upper_bound); 
    h = (upper - lower)/N; 
    ans = (function(lower) + function(upper))/2.0; 
    for (i = 1; i < N; ++i) { 
     ans += function(i * h); 
    } 
    printf("The integral is: %.20lf\n", h * ans)); 

    return 0; 
} 

double function(double x) 
{ 
    return sin(x); 
} 

Cela va bien jusqu'à ce que N devient très grand. J'ai fait une mise en œuvre avec openMP qui est plus rapide mais je pense que ce sera utile d'en savoir un peu plus sur CUDA. Est-ce que quelqu'un a eu des suggestions sur où commencer ou s'il y a une manière indolore de convertir ce code? Merci beaucoup, Jack.

Answer 1

Vous pouvez vous débarrasser de la multiplication: D

double nomul = h; 
    for (i = 1; i < N; ++i) { 
     ans += function(nomul); 
     nomul += h; 
    } 

Answer 2

Tout d'abord, aller de l'avant et installer CUDA sur votre ordinateur. Après cela, essayez d'exécuter certains des exemples disponibles sur le SDK. Ils peuvent sembler un peu compliqués à première vue, mais ne vous inquiétez pas, il existe des tonnes d'exemples CUDA "Hello World" sur le web.

Si vous cherchez quelque chose colombophile, vous pouvez essayer de compiler this project (vous aurez besoin d'installer OpenCV), qui convertit une image à sa représentation en niveaux de gris (il a des fichiers à compiler sur Windows/Linux/Mac OS X, il vaut donc la peine de jeter un oeil si vous avez besoin d'aide pour compiler vos projets).

Answer 3

C'est la boucle qui devrait être distribuée aux threads parallèles. Vous pouvez calculer un index unique pour chaque thread (idx = 0 ... N-1). Chaque thread calcule simplement sa partie individuelle de l'intégrale et stocke la réponse dans sa position dans un tableau commun (intgrl [idx]). Vous résumez ensuite tout en utilisant une procédure appelée analyse parallèle ou collecte. Il y a des exemples dans les exemples de NVIDIA cuda. Le moyen le plus simple serait d'utiliser la bibliothèque Thrust. Vous lui dites simplement "additionnez ces valeurs" et il calcule la méthode la plus rapide.