Générateur de nombres aléatoires dans CUDA

J'ai lutté avec cela tous les jours, je suis en train d'essayer d'obtenir un générateur de nombre aléatoire pour les threads dans mon code CUDA. J'ai regardé à travers tous les forums et oui ce sujet est un peu juste mais j'ai passé des heures à essayer de démêler toutes sortes de codes en vain. Si quelqu'un connaît une méthode simple, sans doute un appareil noyau qui peut être appelée pour des rendements aléatoires de flotter entre 0 et 1, ou un entier que je peux transformer je vous en serais très reconnaissant.

De nouveau, j'espère que d'utiliser le nombre aléatoire dans le noyau, tout comme rand() par exemple.

Merci d'avance

source d'informationauteur zenna

  1. 5

    Je ne suis pas sûr de comprendre pourquoi vous avez besoin de quelque chose de spécial. Traditionnelle PRNG devraient port plus ou moins directement. Un à congruence linéaire devrait fonctionner correctement. Avez-vous quelques propriétés spéciales que vous essayez de mettre en place?

  2. 11

    Pour toute personne intéressée, vous pouvez désormais le faire via cuRAND.

  3. 4

    Je pense que toute discussion de cette question doit répondre à Zenna de l'original, la demande et qui est pour une niveau de thread mise en œuvre. Plus spécifiquement, un fonctionnement de l'appareil qui peuvent être appelées depuis un noyau ou le fil. Désolé si j'ai exagéré le "gras" des expressions, mais je pense que les réponses ne sont pas tout à fait d'adressage de ce qui est recherché ici.

    La cuRAND bibliothèque est votre meilleur pari. Je comprends que les gens veulent réinventer la roue (il permet d'apprécier et de plus correct d'utiliser la 3ème partie des bibliothèques), mais de haute performance de haute qualité des générateurs de nombres sont copieux et bien testé. Les meilleures infos que je peux recommander, sur la documentation de la GSL bibliothèque sur les différents générateurs ici:http://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html

    Pour tout sérieux de code, il est préférable d'utiliser l'un des principaux algorithmes de mathématiciens/ordinateur-les scientifiques ont dans le sol au-dessus et sur la recherche de faiblesses systémiques. Le "mersenne twister" est quelque chose avec une période (à répéter en boucle) sur l'ordre de 10^6000 (MT19997 algorithme signifie "Mersenne Twister 2^19997") qui a été spécialement adapté pour les Nvidia à utiliser et à un niveau de thread dans les threads d'un même warp à l'aide de l'id de thread appels sous forme de graines. Voir l'article ici:http://developer.download.nvidia.com/compute/cuda/2_2/sdk/website/projects/MersenneTwister/doc/MersenneTwister.pdf. Je suis en train de travailler pour mettre en œuvre somehting l'utilisation de cette bibliothèque et SI je l'obtenir pour fonctionner correctement, je vais poster mon code. Nvidia a quelques exemples sur leur site de documentation pour l'actuel CUDA toolkit.

    NOTE: Juste pour le dossier je ne travaille pas pour Nvidia, mais j'avoue que leur documentation et d'abstraction de la conception pour CUDA est quelque chose que j'ai été impressionné par.

  4. 4

    En fonction de votre demande, vous devriez se méfier de l'utilisation de LCGs sans tenir compte de savoir si le cours d'eau (un flux par thread) se chevauchent. Vous pourriez mettre en œuvre un saute-mouton avec LCG, mais alors vous devez avoir une période suffisamment longue LCG pour s'assurer que la séquence ne se répètent pas.

    Un exemple leapfrog pourrait être:

    template <typename ValueType>
__device__ void leapfrog(unsigned long &a, unsigned long &c, int leap)
{
    unsigned long an = a;
    for (int i = 1 ; i < leap ; i++)
        an *= a;
    c = c * ((an - 1) / (a - 1));
    a = an;
}

template <typename ValueType>
__device__ ValueType quickrand(unsigned long &seed, const unsigned long a, const unsigned long c)
{
    seed = seed * a;
    return seed;
}

template <typename ValueType>
__global__ void mykernel(
    unsigned long *d_seeds)
{
    //RNG parameters
    unsigned long a = 1664525L;
    unsigned long c = 1013904223L;
    unsigned long ainit = a;
    unsigned long cinit = c;
    unsigned long seed;

    //Generate local seed
    seed = d_seeds[bid];
    leapfrog<ValueType>(ainit, cinit, tid);
    quickrand<ValueType>(seed, ainit, cinit);
    leapfrog<ValueType>(a, c, blockDim.x);

    ...
}

    Mais alors la période de ce générateur est probablement insuffisante dans la plupart des cas.

    Pour être honnête, j'aurais l'air à l'aide d'un tiers bibliothèque comme NAG. Il y a quelques lots de générateurs dans le SDK trop, mais ce n'est probablement pas ce que vous cherchez dans ce cas.

    MODIFIER

    Depuis cette juste se leva-voter, je me dis qu'il vaut la peine de la mise à jour de mentionner que cuRANDcomme indiqué par la plus récente des réponses à cette question, est disponible et fournit un certain nombre de générateurs et de distributions. C'est certainement l'endroit le plus facile pour commencer.

  5. 3

    Le meilleur moyen pour cela est d'écrire votre propre appareil fonction , ici, est l'un 

    void RNG()
{   
    unsigned int m_w = 150;
    unsigned int m_z = 40;

    for(int i=0; i < 100; i++)
    {
        m_z = 36969 * (m_z & 65535) + (m_z >> 16);
        m_w = 18000 * (m_w & 65535) + (m_w >> 16);

        cout <<(m_z << 16) + m_w << endl;  /* 32-bit result */
    }
}

    Elle vous donne 100 nombres aléatoires avec 32 bits de résultat.

    Si vous voulez un peu de nombres aléatoires entre 1 et 1000, vous pouvez aussi prendre le result%1000soit au point de consommation, ou au point de génération:

    ((m_z << 16) + m_w)%1000

    Changer m_w et m_z valeurs de départ (dans l'exemple, 150 et 40) vous permet d'obtenir des résultats différents à chaque fois. Vous pouvez utiliser threadIdx.x que l'un d'entre eux, ce qui devrait vous donner différentes pseudo-aléatoire de la série à chaque fois.

    Je voulais ajouter que cela fonctionne 2 fois plus rapide que la fonction rand (), et fonctionne très bien 😉

  6. 2

    Il y a un MDGPU paquet (GPL), qui comprend une mise en œuvre de la GNU rand48() fonction pour CUDA ici.

    Je l'ai trouvé (assez facilement, à l'aide de Google, je suppose que vous avez essayé 🙂 sur la NVidia forums ici.

  7. 2

    Je n'ai pas trouvé un bon parallèle générateur de nombre de CUDA, cependant, j'ai trouvé un parallèle générateur de nombre aléatoire basé sur la recherche universitaire ici: http://sprng.cs.fsu.edu/

  8. 0

    Vous pourriez essayer Mersenne Twister pour les Gpu

    Il est basé sur SIMD orientée Rapide Mersenne Twister (SFMT) qui est une tout à fait fiable et rapide de générateur de nombre aléatoire. Il passe Marsaglias INCONDITIONNELS de tests pour les Générateurs de nombres Aléatoires.