Quelle est la fonction la plus triviale qui gagnerait à être calculé sur un GPU?

Question

Je viens juste de commencer l'apprentissage OpenCL. Je suis en train de se faire une idée de ce que les gains de performance à attendre lors du déplacement des fonctions / algorithmes pour le GPU.

Le noyau le plus élémentaire donnée dans la plupart des tutoriels est un noyau qui prend deux tableaux de nombres et additionne la valeur aux indices correspondants et les ajoute à un troisième tableau, comme ceci:

__kernel void 
add(__global float *a,
    __global float *b,
    __global float *answer)
{
    int gid = get_global_id(0);
    answer[gid] = a[gid] + b[gid];
}

__kernel void
sub(__global float* n,
    __global float* answer)
{
    int gid = get_global_id(0);
    answer[gid] = n[gid] - 2;
}

__kernel void
ranksort(__global const float *a,
         __global float *answer)
{
  int gid = get_global_id(0);
  int gSize = get_global_size(0);
  int x = 0;
  for(int i = 0; i < gSize; i++){
    if(a[gid] > a[i]) x++;
  }
  answer[x] = a[gid];
}

Je suppose que vous pourriez ne justifiera jamais calculer ce sur le GPU, le transfert de mémoire serait en poids le temps qu'il faudrait calculer cela sur la CPU par des grandeurs (je peux me tromper à ce sujet, donc cette question).

Ce que je me demande est ce que serait l'exemple le plus trivial où on peut s'y attendre lors de l'utilisation importante speedup un noyau OpenCL au lieu de la CPU?

Answer 1

si vous avez un ensemble de matrices suffisamment grand vous avez l'intention d'effectuer des opérations d'algèbre linéaire sur, ou que vous êtes essentiellement d'effectuer la même opération sur chaque élément, je considère cela comme un exemple trivial. multiplication matricielle, outre, de TFR, convolution, etc., vous verrez un peu sans faire beaucoup speedup travail. maintenant si vous voulez voir les speedups 100x alors vous devez plonger dans la gestion de la mémoire et de savoir un peu juste sur ce qui se passe dans les coulisses.

pour commencer, je recommanderais à commencer par pycuda car il est assez simple pour commencer, car il offre un niveau très élevé d'abstraction et vous permettra de sauter très rapidement. consultez ce cours sur l'informatique parallèle à l'aide cuda de l'université de l'illinois http: //courses.ece. illinois.edu/ece498/al/ lorsque vous êtes prêt à plonger plus loin.

Answer 2

dépend de la définition de trivial. à mon avis, il serait produit matriciel matrice, car il a O(3)/O(2) calculer le ratio de la mémoire. Les algorithmes qui présentent des rapports similaires, sont susceptibles de bénéficier d'être en concurrence sur le GPU.

Answer 3

Alors que votre noyau est clairement très trivial, il peut être un exemple utile, il est tout à la mémoire liée depuis pour chaque élément que vous avez deux lectures et une écriture, et une seule opération arithmétique. Il y a quelques instructions pour calculer l'adresse, etc., mais tout cela revient à pratiquement rien par rapport au coût d'accès à la mémoire.

En supposant que les données sont déjà sur le GPU, vous pouvez bénéficier de très haut débit à la mémoire du GPU même pour ce noyau simple.

Bien sûr, les GPUs comptent sur vous avoir suffisamment de threads pour masquer la latence de la mémoire, de sorte que la taille de votre groupe de travail locale devrait être assez grand (disons 256 ou 512) et la taille de votre groupe de travail global devrait être très grand (par exemple, des centaines de milliers ) pour que cela soit efficace, mais c'est un peu le point!

Answer 4

Je sais que la question est assez vieux, mais ... je trouve que les calculs de l'ensemble de Mandelbrot est tout à fait optimale pour GPU. Vous avez un vecteur d'entrée complexe (float2) et une sortie scalaire (int) et vous aurez une centaine d'opérations par vecteur d'entrée en moyenne.

Il pourrait être utilisé comme une bonne application par exemple, comme il ...

• dispose d'un ensemble de données d'entrée en 2 dimensions (calcule une image)
• vous pouvez expliquer pourquoi 2 fronts d'onde et le traitement tridimensionnel est bénéfique dans certains cas,
• types de données démontre antivectorielle
• produit une image, qui est rapidement vérifiable par des yeux humains (débogage)
• peut être facilement étendu par: la cartographie couleur (__constant), le traitement au lieu de float4 float2 (optimisation), produisant int4 (R, G, B, A) des vecteurs de sortie (optimisation). des étapes de réduction (RVBA) => (RGB)
• connaissances nécessaires en mathématiques est acceptable (formule simple)

Cordialement, Stefan

Answer 5

Après la multiplication de la matrice, je dirais convolution d'image (tels que le flou, débruitage, etc.). Consultez tutoriel d'AMD.

Answer 6

Ce qui est « le plus trivial » est une question d'opinion, mais je dirais que le calcul d'une image de l'ensemble de Mandelbrot est une application assez simple en utilisant le GPU. Chaque point est totalement indépendant de tous les autres points, de sorte que vous pouvez démarrer un fil pour chaque point et obtenir gain de vitesse énorme. La formule elle-même qui est itérer est une fonction quadratique simple. Je l'ai utilisé comme un exemple dans un tutoriel qui peut être trouvé sur mon blog ici , juste calculer les nombres sans même faire une image pour le rendre encore plus simple. Presque tout problème embarrassant parallèle (voir l'entrée Wikipedia) est un bon pour commencer.