CUDA: la copia della memoria di GPU 1 è più lento in multi-GPU

Question

La mia azienda ha una messa a punto di due GTX 295, per un totale di 4 GPU in un server, e abbiamo diversi server. Abbiamo GPU specificamente 1 era lento, in confronto a GPU 0, 2 e 3 così ho scritto un po 'di velocità di prova per aiutare a trovare la causa del problema.

//#include <stdio.h>
//#include <stdlib.h>
//#include <cuda_runtime.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cutil.h>

__global__ void test_kernel(float *d_data) {
    int tid = blockDim.x*blockIdx.x + threadIdx.x;
    for (int i=0;i<10000;++i) {
        d_data[tid] = float(i*2.2);
        d_data[tid] += 3.3;
    }
}

int main(int argc, char* argv[])
{

    int deviceCount;                                                         
    cudaGetDeviceCount(&deviceCount);
    int device = 0; //SELECT GPU HERE
    cudaSetDevice(device);


    cudaEvent_t start, stop;
    unsigned int num_vals = 200000000;
    float *h_data = new float[num_vals];
    for (int i=0;i<num_vals;++i) {
        h_data[i] = float(i);
    }

    float *d_data = NULL;
    float malloc_timer;
    cudaEventCreate(&start);
    cudaEventCreate(&stop); cudaEventRecord( start, 0 );
    cudaMemcpy(d_data, h_data, sizeof(float)*num_vals,cudaMemcpyHostToDevice);
    cudaMalloc((void**)&d_data, sizeof(float)*num_vals);
    cudaEventRecord( stop, 0 ); cudaEventSynchronize( stop ); cudaEventElapsedTime( &malloc_timer, start, stop );
    cudaEventDestroy( start );
    cudaEventDestroy( stop );


    float mem_timer;
    cudaEventCreate(&start);
    cudaEventCreate(&stop); cudaEventRecord( start, 0 );
    cudaMemcpy(d_data, h_data, sizeof(float)*num_vals,cudaMemcpyHostToDevice);
    cudaEventRecord( stop, 0 ); cudaEventSynchronize( stop ); cudaEventElapsedTime( &mem_timer, start, stop );
    cudaEventDestroy( start );
    cudaEventDestroy( stop );

    float kernel_timer;
    cudaEventCreate(&start);
    cudaEventCreate(&stop); cudaEventRecord( start, 0 );
    test_kernel<<<1000,256>>>(d_data);
    cudaEventRecord( stop, 0 ); cudaEventSynchronize( stop ); cudaEventElapsedTime( &kernel_timer, start, stop );
    cudaEventDestroy( start );
    cudaEventDestroy( stop );

    printf("cudaMalloc took %f ms\n",malloc_timer);
    printf("Copy to the GPU took %f ms\n",mem_timer);
    printf("Test Kernel took %f ms\n",kernel_timer);

    cudaMemcpy(h_data,d_data, sizeof(float)*num_vals,cudaMemcpyDeviceToHost);

    delete[] h_data;
    return 0;
}

I risultati sono

GPU0 cudaMalloc preso 0.908640 ms Copia per la GPU ha 296.058777 ms Prova Kernel preso 326.721283 ms

GPU1 cudaMalloc preso 0.913568 ms Copiare alla GPU ha 663.182251 ms Prova Kernel preso 326.710785 ms

GPU2 cudaMalloc preso 0.925600 ms Copia per la GPU ha 296.915039 ms Prova Kernel preso 327.127930 ms

GPU3 cudaMalloc preso 0.920416 ms Copia per la GPU ha 296.968384 ms Prova Kernel preso 327.038696 ms

Come si può vedere, la cudaMemcpy alla GPU è ben il doppio della quantità di tempo per GPU1. Ciò è coerente tra tutti i nostri server, è sempre GPU1 che è lento. Tutte le idee perché questo può essere? Tutti i server sono in esecuzione Windows XP.

Answer 1

Questo è stato un problema di driver. Aggiornamento per il driver più recente è stato risolto

Answer 2

Questo può essere un problema con il bus PCI, provare a scambiare le carte in diversi slot per vedere se i persiste problema. Se questo è un problema, copiare tutti i dati sul GTX295 tramite lo slot più veloce e utilizzare top sli copiarlo attraverso all'altro (lento bus PCI) gpu.

Answer 3

Se è possibile utilizzato GDDR della scheda video più veloce al carico, allora si può fare un tansfer dispositivo dispositivo di una larghezza di banda molto molto più elevato, che potrebbe aiutare a eliminare il problema anche. Inoltre, controllare la larghezza di banda con il test di banda di NVIDIA per ottenere alcuni risultati fisici e test.

In bocca al lupo!

Answer 4

Siete in esecuzione in una configurazione a doppio processore? C'è un bug nel corrente Tylersburg chipset tale che la larghezza di banda del x86 percorso (0) per GPU (1) è più lento del percorso diretto da X 86 (0) per GPU (0). Intel dovrebbe rilasciare una nuova versione per risolvere questo bug. Prova il blocco della procedura di prova per una CPU specifica usando taskset e vedere quali risultati si ottiene.

saluti Mark