CUDA Data Parallel Primitives.

Cette API, écrite en C, est orientée vers les algorithmes de traitement des données parallèles : réduction, tri... Ces algorithmes sont primitifs : pas forcément triviaux à bien implémenter, mais toujours utiles dans tous les domaine (de la compression des données au traitement numérique de ces données).

CUDPP est prévue pour être surtout très optimisée, en facilitant un maximum les opérations. Le passage du CPU au GPU se fait presque sans douleur.

Tout algorithme de CUDPP doit être préalablement configuré, grâce à une structure de type CUDPPConfiguration. Cette structure est ainsi définie.

struct CUDPPConfiguration
{
    CUDPPAlgorithm algorithm;
    CUDPPOperator  op;
    CUDPPDatatype  datatype;
    unsigned int   options;
};

Premièrement, nous utilisons une variable de type CUDPPAlgorithm pour configurer un algorithme. Il s'agit, justement, de l'algorithme à employer.

• CUDPP_SCAN
• CUDPP_SEGMENTED_SCAN
• CUDPP_COMPACT
• CUDPP_REDUCE
• CUDPP_SORT_RADIX
• CUDPP_SORT_RADIX_GLOBAL
• CUDPP_SPMVMULT
• CUDPP_SORT_INVALID

Évidemment, cet algorithme devra correspondre à la fonction appelée plus tard avec cette configuration.

Deuxièmement, vous pouvez spécifier un opérateur, l'opération qui sera effectuée, uniquement lors d'un scan. Pour les autres algorithmes, laissez ceci vide.

Tous ces opérateurs sont binairement associables.

• CUDPP_ADD
• CUDPP_MULTIPLY
• CUDPP_MIN
• CUDPP_MAX

Troisièmement, vous devez définir le type des données en entrée et en sortie. Voici un tableau récapitulatif de ces valeurs, avec leur équivalent en C.

Finalement, la configuration d'un algorithme se fait, finalement, aussi grâce à un entier. Cet entier est constitué d'une combinaison de paramètres, grâce à l'opérateur pipe (|).

cudppPlan() crée un plan planHandler, qui respectera la configuration config, qui traitera n éléments répartis en rows colonnes de rowPitch éléments chacune.

Le plan sera détruit par la fonction cudppDesroyPlan() dès qu'il ne sera plus utilisé.

CUDPPResult cudppPlan(CUDPPHandle        * planHandle, 
                      CUDPPConfiguration config, 
                      size_t             n, 
                      size_t             rows, 
                      size_t             rowPitch);
                      
CUDPPResult cudppDestroyPlan(CUDPPHandle plan);

CUDPP propose plusieurs fonctions pour effectuer des scans. Les voici.

CUDPPResult cudppScan(CUDPPHandle   planHandle,
                      void        * d_out, 
                      const void  * d_in, 
                      size_t        numElements);

Les données à traiter se situent sur le GPU, à l'emplacement pointé par d_in ; la sortie se situe aussi sur le GPU, à l'emplacement pointé par d_out. La fonction utilisera les options prévues dans le plan planHandle, et scannera numElements éléments.

CUDPPResult cudppSegmentedScan(CUDPPHandle          planHandle,
                               void               * d_out, 
                               const void         * d_idata,
                               const unsigned int * d_iflags,
                               size_t               numElements);

La fonction traitera les segments précisés dans d_iflags de d_idata.

CUDPPResult cudppMultiScan(CUDPPHandle planHandle,
                           void        *d_out, 
                           const void  *d_in, 
                           size_t      numElements,
                           size_t      numRows);

La fonction effectuera numRows scans sur les données avant d'écrire le résultat.

CUDPPResult cudppCompact(CUDPPHandle          planHandle,
                         void               * d_out, 
                         size_t             * d_numValidElements,
                         const void         * d_in, 
                         const unsigned int * d_isValid,
                         size_t               numElements);

Cette fonction compacte un tableau, avec les éléments d_isValid définis comme valides, les autres étant à éjecter. d_numValidElements sera le nombre d'éléments effectivement gardés.

Il n'existe, pour le moment, qu'une seule fonction de tri de tableau.

CUDPPResult cudppSort(CUDPPHandle planHandle,
                      void        *d_out, 
                      const void  *d_in,
                      size_t      numElements);

d_out est un pointeur vers le tableau, quand il sera trié. d_in, vers le tableau à trier. Ces tableaux contiendront numElements.

Chaque fonction de CUDPP renvoie un CUDPPResult, qui peut prendre quelques valeurs, en fonction de l'erreur qui s'est déroulée.