CUDA: Speicherkopie GPU 1 ist langsamer in Multi-GPU

Question

Meine Firma hat eine Einrichtung von zwei GTX 295, so insgesamt 4 GPUs in einem Server, und wir mehrere Server haben. Wir GPU 1 speziell langsam war, im Vergleich zu GPU 0, 2 und 3, damit ich einen wenig Speed-Test, um die Ursache des Problems finden geschrieben.

//#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;
}

Die Ergebnisse sind

GPU0 cudaMalloc nahm 0.908640 ms Kopie an die GPU nahm 296.058777 ms Testkernel nahm 326.721283 ms

GPU1 cudaMalloc nahm 0.913568 ms Kopieren Sie auf die GPU nahm 663.182251 ms Testkernel nahm 326.710785 ms

GPU2 cudaMalloc nahm 0.925600 ms Kopie an die GPU nahm 296.915039 ms Testkernel nahm 327.127930 ms

GPU3 cudaMalloc nahm 0.920416 ms Kopie an die GPU nahm 296.968384 ms Testkernel nahm 327.038696 ms

Wie Sie sehen können, die cudaMemcpy auf die GPU ist gut doppelt so viel Zeit für GPU1. Dies steht im Einklang zwischen all unseren Servern, ist es immer GPU1, die langsam ist. Irgendwelche Ideen, warum dies auch sein mag? Alle Server sind mit Windows XP.

Answer 1

Dies war ein Treiber Problem. Ein Update auf den neuesten Treiber regelte es

Answer 2

Dies kann ein Problem mit dem PCI-Bus sein, versuchen, die Karten in verschiedene Slots tauschen, wenn das Problem weiterhin besteht, um zu sehen. Wenn dies ein Problem ist, kopieren Sie alle Ihre Daten auf die GTX295 über den schnelleren Schlitz und verwendet sli Top es auf den anderen (langsamen PCI-Bus) gpu kopieren.

Answer 3

Wenn Sie die schnellere Grafikkarte des GDDR zu Last verwendet, dann können Sie bei vielen vielen höheren Bandbreite ein Gerät Gerät tansfer tun, das könnte auch dazu beitragen, das Problem zu beseitigen. Überprüfen Sie auch Ihre Bandbreite mit NVidia Bandbreite Tests einige physikalische Ergebnisse und Test zu erhalten.

Viel Glück!

Answer 4

Sind Sie mit in einem Dual-Prozessor-Setup? Es ist ein Fehler in der aktuellen Tylersburg Chipsatz, so dass die Bandbreite des Pfad x86 (0) bis GPU (1) langsamer ist als der direkte Weg vom x86 (0) bis GPU (0). Intel sollte eine neue Version veröffentlicht diesen Fehler zu beheben. Versuchen Sie Sperren Ihre Testprozess zu einer bestimmten CPU mit taskset und welche Ergebnisse Sie bekommen.

Grüße Mark