performance - example - install tensorflow gpu

CUDA: la copia de memoria a GPU 1 es más lenta en multi-GPU

Question

Mi empresa tiene una configuración de dos GTX 295, por lo que un total de 4 GPU en un servidor, y tenemos varios servidores. La GPU 1 específicamente fue lenta, en comparación con GPU 0, 2 y 3, así que escribí una pequeña prueba de velocidad para ayudar a encontrar 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;
}

Los resultados son

GPU0 cudaMalloc tomó 0.908640 ms La copia en la GPU tomó 296.058777 ms Kernel de prueba tomó 326.721283 ms

GPU1 cudaMalloc tomó 0.913568 ms Copiar a la GPU tomó 663.182251 ms Kernel de prueba tomó 326.710785 ms

GPU2 cudaMalloc tomó 0.925600 ms Copiar a la GPU tomó 296.915039 ms Kernel de prueba tomó 327.127930 ms

GPU3 cudaMalloc tomó 0.920416 ms La copia en la GPU tomó 296.968384 ms Kernel de prueba tomó 327.038696 ms

Como puede ver, el cudaMemcpy para la GPU es el doble de la cantidad de tiempo para GPU1. Esto es coherente entre todos nuestros servidores, siempre es GPU1 que es lento. ¿Alguna idea de por qué esto puede ser? Todos los servidores ejecutan Windows XP.

Answer 1

Esto puede ser un problema con su bus pci, intente intercambiar las tarjetas en diferentes ranuras para ver si el problema persiste. Si esto es un problema, copie todos sus datos en el gtx295 a través de la ranura más rápida y use sli top y cópielo en el otro (gmin pci bus) gpu.

Answer 2

Si puede utilizar el gddr de la tarjeta de video más rápida para cargar, entonces puede hacer un dispositivo con tansfer a un MUCHO mayor ancho de banda, que también puede ayudar a eliminar el problema. Además, verifique su ancho de banda con la prueba de ancho de banda de NVidia para obtener algunos resultados físicos y pruebas.

¡Buena suerte!

Answer 3

¿Estás corriendo en una configuración de procesador dual? Existe un error en los conjuntos de chips actuales de Tylersburg, de modo que el ancho de banda de la ruta x86 (0) a la GPU (1) es más lento que la ruta directa de x86 (0) a GPU (0). Intel debería lanzar una nueva versión para solucionar este error. Intente bloquear su proceso de prueba a una CPU específica usando el conjunto de tareas y vea qué resultados obtiene.

Respetos Mark

Answer 4

Este fue un problema con el conductor. La actualización al último controlador lo arregló