CUDA global (comme en C) tableaux dynamiques alloué à la mémoire de l'appareil

Passer un peu de temps à se concentrer sur l'abondante documentation offert par NVIDIA.

À partir du Guide de Programmation:

float* devPtr;
cudaMalloc((void**)&devPtr, 256 * sizeof(*devPtr));
cudaMemset(devPtr, 0, 256 * sizeof(*devPtr));

C'est un exemple simple de comment allouer de la mémoire. Maintenant, dans vos noyaux, vous devez accepter un pointeur vers un float:

__global__
void kernel1(float *some_neat_data)
{
    some_neat_data[threadIdx.x]++;
}

__global__
void kernel2(float *potentially_that_same_neat_data)
{
    potentially_that_same_neat_data[threadIdx.x] *= 0.3f;
}

Alors maintenant, vous pouvez les appeler de la sorte:

float* devPtr;
cudaMalloc((void**)&devPtr, 256 * sizeof(*devPtr));
cudaMemset(devPtr, 0, 256 * sizeof(*devPtr));

kernel1<<<1,128>>>(devPtr);
kernel2<<<1,128>>>(devPtr);

Comme ce type de données est utilisé dans de nombreuses
fonctions, je voudrais qu'il soit
mondial de.

Il y a quelques bonnes raisons d'utiliser des variables globales. Ce n'est certainement pas un. Je vais le laisser comme un exercice d'étendre cet exemple à inclure le déplacement "devPtr" à une portée globale.

EDIT:

Ok, le problème fondamental est: est-ce votre les grains ne peuvent accéder à la mémoire de l'appareil et le seul champ d'application mondial des pointeurs qu'ils peuvent utiliser sont GPU. Lors de l'appel d'un noyau à partir de votre CPU, les coulisses de ce qui se passe est que les pointeurs et les primitives sont copiés dans GPU registres et/ou de la mémoire partagée avant que le noyau ne soit exécutée.

De sorte que le plus proche que je peux suggérer, c'est ceci: utiliser cudaMemcpyToSymbol() pour atteindre vos objectifs. Mais, dans le fond, considèrent qu'une approche différente pourrait être la bonne Chose.

#include <algorithm>

__constant__ float devPtr[1024];

__global__
void kernel1(float *some_neat_data)
{
    some_neat_data[threadIdx.x] = devPtr[0] * devPtr[1];
}

__global__
void kernel2(float *potentially_that_same_neat_data)
{
    potentially_that_same_neat_data[threadIdx.x] *= devPtr[2];
}


int main(int argc, char *argv[])
{
    float some_data[256];
    for (int i = 0; i < sizeof(some_data) / sizeof(some_data[0]); i++)
    {
        some_data[i] = i * 2;
    }
    cudaMemcpyToSymbol(devPtr, some_data, std::min(sizeof(some_data), sizeof(devPtr) ));
    float* otherDevPtr;
    cudaMalloc((void**)&otherDevPtr, 256 * sizeof(*otherDevPtr));
    cudaMemset(otherDevPtr, 0, 256 * sizeof(*otherDevPtr));

    kernel1<<<1,128>>>(otherDevPtr);
    kernel2<<<1,128>>>(otherDevPtr);

    return 0;
}

N'oubliez pas '--host-compilation=c++ " pour cet exemple.

OriginalL'auteur

Erm, c'était exactement le problème de déplacement de devPtr de portée mondiale, qui a été mon problème.

J'ai une application qui fait exactement cela, avec les deux noyaux ayant un pointeur vers les données transmises. J'ai explicitement ne voulez pas passer dans ces pointeurs.

J'ai lu la documentation d'assez près, et de frapper les nvidia forums (et recherchée sur google pour une heure ou deux), mais je n'ai pas trouvé de mise en œuvre d'une dynamique globale de l'appareil tableau qui fonctionne en fait (j'ai essayé plusieurs que de compiler et d'échouer dans des façons nouvelles et intéressantes).

OriginalL'auteur Voltaire

Comme ce type de données est utilisé dans de nombreuses fonctions, je voudrais qu'il soit global.

-

Il y a quelques bonnes raisons d'utiliser des variables globales. Ce n'est certainement pas un. Je vais la laisser
exercice pour étendre cet exemple à inclure le déplacement "devPtr" à une portée globale.

Que si le noyau fonctionne sur un grand const structure composée de tableaux? À l'aide de la dite constante de la mémoire n'est pas une option, parce que c'est très limitée dans la taille.. alors vous devez le mettre dans la mémoire globale..?

OriginalL'auteur Nils