CUDA:A cópia da memória para GPU 1 é mais lenta em multi-GPU

Question

Minha empresa tem uma configuração de duas GTX 295, ou seja, um total de 4 GPUs em um servidor, e temos vários servidores.A GPU 1 especificamente era lenta, em comparação com as GPU 0, 2 e 3, então escrevi um pequeno teste de velocidade para ajudar a encontrar a causa do 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;
}

Os resultados são

GPU0 Cudamalloc levou 0,908640 ms A cópia da GPU levou 296.058777 ms: o kernel de teste levou 326.721283 ms

GPU1 Cudamalloc levou 0,913568 ms A cópia para a GPU levou 663,182251msO kernel de teste levou 326,710785 ms

O GPU2 Cudamalloc levou 0,925600 ms para a GPU levou 296.915039 ms: o kernel de teste levou 327.127930 ms

GPU3 Cudamalloc levou 0,920416 ms A cópia para a GPU levou 296.968384 ms de teste Kernel levou 327.038696 ms

Como você pode ver, o cudaMemcpy para a GPU é o dobro da quantidade de tempo da GPU1.Isso é consistente entre todos os nossos servidores, é sempre o GPU1 que está lento.Alguma idéia de por que isso pode acontecer?Todos os servidores estão executando o Windows XP.

Answer 1

Este foi um problema de motorista. Atualizando para o driver mais recente corrigiu -o

Answer 2

Isso pode ser um problema com o seu barramento PCI, tente trocar os cartões em slots diferentes para ver se o problema persiste. Se isso for um problema, copie todos os seus dados para o GTX295 através do slot mais rápido e use o SLI Top Copy -o para a outra GPU (barramento PCI lento).

Answer 3

Se você puder utilizar o GDDR da placa de vídeo mais rápido para carregar, poderá fazer uma tomada de dispositivo com largura de banda muito mais alta, isso também pode ajudar a eliminar o problema. Além disso, verifique sua largura de banda com os testes de largura de banda da NVIDIA para obter alguns resultados físicos e testar.

Boa sorte!

Answer 4

Você está executando em uma configuração de processador duplo?Há um bug nos chipsets atuais de Tylersburg, de modo que a largura de banda do caminho x86 (0) para GPU (1) é mais lenta do que o caminho direto de x86 (0) para GPU (0).A Intel deve lançar uma nova versão para corrigir esse bug.Tente bloquear seu processo de teste para uma CPU específica usando o conjunto de tarefas e veja quais resultados você obtém.

Atenciosamente Mark