Optimiser CUDA avec poussée dans une boucle

Question

Etant donné le morceau de code suivant, la génération d'un type de dictionnaire de codes avec CUDA utilisant la poussée (C ++ bibliothèque de modèles pour CUDA):

thrust::device_vector<float> dCodes(codes->begin(), codes->end());
thrust::device_vector<int> dCounts(counts->begin(), counts->end());
thrust::device_vector<int> newCounts(counts->size());

for (int i = 0; i < dCodes.size(); i++) {
    float code = dCodes[i];
    int count = thrust::count(dCodes.begin(), dCodes.end(), code);

    newCounts[i] = dCounts[i] + count;

    //Had we already a count in one of the last runs?
    if (dCounts[i] > 0) {
        newCounts[i]--;
    }

    //Remove
    thrust::detail::normal_iterator<thrust::device_ptr<float> > newEnd = thrust::remove(dCodes.begin()+i+1, dCodes.end(), code);
    int dist = thrust::distance(dCodes.begin(), newEnd);
    dCodes.resize(dist);
    newCounts.resize(dist);
}

codes->resize(dCodes.size());
counts->resize(newCounts.size());

thrust::copy(dCodes.begin(), dCodes.end(), codes->begin());
thrust::copy(newCounts.begin(), newCounts.end(), counts->begin());

Le problème est que je l'ai remarqué plusieurs copies de 4 octets, en utilisant profileur visuelle CUDA. OMI, est généré par

1. Le compteur de boucle i
2. code float , int count et dist
3. Chaque accès à i et les variables mentionnées ci-dessus

Cela semble ralentir tout (la copie séquentielle de 4 octets est pas drôle ...).

Alors, comment je vais dire la poussée, que ces variables doivent être traitées sur l'appareil? Ou sont-ils déjà?

Utilisation poussée :: device_ptr semble ne suffit pas pour moi, parce que je ne suis pas sûr que la boucle tourne autour sur l'hôte ou sur l'appareil (qui pourrait aussi être une autre raison pour la la lenteur).

Answer 1

pour chaque réitération de i, taille, index, code, etc. doivent être copiés de l'hôte à l'appareil .. la façon dont vous avez votre programme, il n'y a pas grand-chose que vous pouvez faire. Pour de meilleurs résultats, envisager de déplacer la boucle entière i sur l'appareil, de cette façon vous n'aurez pas l'hôte de copies de l'appareil.

La confiance est grande pour certaines choses, mais où la performance est concerné et l'algorithme ne fonctionne tout à fait disponibles, vous devrez éventuellement réécrire pour de meilleures performances sans utiliser des algorithmes de poussée explicitement.