Quand appeler cudadevicesynchroniser?

bien que les lancements du noyau CUDA soient asynchrones, toutes les tâches liées au GPU placées dans un flux (qui est le comportement par défaut) sont exécutées de façon séquentielle.

ainsi, par exemple,

kernel1<<<X,Y>>>(...); // kernel start execution, CPU continues to next statement
kernel2<<<X,Y>>>(...); // kernel is placed in queue and will start after kernel1 finishes, CPU continues to next statement
cudaMemcpy(...); // CPU blocks until ememory is copied, memory copy starts only after kernel2 finishes

donc dans votre exemple il n'y a pas besoin de cudaDeviceSynchronize. Cependant, il pourrait être utile pour le débogage de détecter lequel de vos noyaux a causé une erreur (s'il y en a).

cudaDeviceSynchronize peut causer un certain ralentissement, mais 7-12x semble de trop. Peut-être il ya un problème avec le temps la mesure, ou peut-être les noyaux sont vraiment rapides, et la charge de synchronisation explicite est énorme par rapport au temps de calcul réel.

une situation oùcudaDeviceSynchronize() est appropriée lorsque vous avez plusieurs cudaStream s en cours, et vous aimeriez qu'ils échangent des informations. Un cas réel de ce phénomène est le revenu parallèle dans les simulations quantiques de Monte Carlo. Dans ce cas, nous voulons nous assurer que chaque flux a terminé l'exécution d'un ensemble d'instructions et a obtenu quelques résultats avant qu'ils commencent à passer des messages les uns aux autres, ou nous finirions par passer des informations sur les ordures. La raison de cette utilisation la commande ralentit tellement le programme que cudaDeviceSynchronize() force le programme à attendre que toutes les commandes précédemment émises dans tous les flux sur l'appareil se terminent avant de continuer (à partir du Guide de programmation CUDA C). Comme vous l'avez dit, l'exécution du noyau est normalement asynchrone, donc pendant que le périphérique GPU exécute votre noyau, le CPU peut continuer à travailler sur d'autres commandes, donner plus d'instructions au périphérique, etc. au lieu d'attendre. Cependant, lorsque vous utilisez cette commande de synchronisation, le CPU est au lieu de cela forcé à l'inactivité jusqu'à ce que tout le travail GPU a terminé avant de faire quoi que ce soit d'autre. Ce comportement est utile lors du débogage, puisque vous pouvez avoir une défaillance de segfault se produisant à des moments apparemment "aléatoires" en raison de l'exécution asynchrone du code de périphérique (que ce soit dans un flux ou plusieurs). cudaDeviceSynchronize() va forcer le programme à s'assurer que les noyaux/memcpys du ou des flux sont complets avant de continuer, ce qui peut rendre plus facile de savoir où les accès illégaux se produisent (puisque l'échec va apparaître pendant la synchronisation).

lorsque vous voulez que votre GPU commence à traiter certaines données, vous faites généralement une invocation kernale. Quand vous le faites, votre appareil (le GPU) commencera à faire ce que vous lui avez dit de faire. Cependant, contrairement à un programme séquentiel normal sur votre hôte (le CPU) continuera d'exécuter les prochaines lignes de code dans votre programme. cudadevicesynchroniser fait attendre l'hôte (le CPU) jusqu'à ce que l'appareil (le GPU) ont terminé l'exécution de tous les threads que vous avez commencé, et donc votre programme continuera comme si c'était normal d'un programme séquentiel.

dans les petits programmes simples, vous utilisez généralement cudadevicesynchroniser, lorsque vous utilisez le GPU pour faire des calculs, pour éviter les décalages entre le CPU demandant le résultat et le GPU finissant le calcul. Utiliser cudadevicesynchroniser rend plus facile de coder votre programme, mais il y a un inconvénient majeur: votre CPU est inactif tout le temps, tandis que le GPU fait le calcul. Par conséquent, dans le calcul de haute performance, vous souvent s'efforcer d'avoir votre CPU faisant des calculs pendant qu'il attend le GPU pour finir.