Mi estación de trabajo tiene dos GPU (Quadro K5200 y Quadro K2200) con el último controlador NVIDIA instalado (Versión: 352.41). Después de descargar el archivo cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debde Descargas de CUDA 7.5 , intento instalarlo, pero el resultado es el siguiente:

root@P700-Bruce:/home/bruce/Downloads# sudo apt-get install cuda
Reading package lists... Done
Building dependency tree       
Reading state information... Done
Some packages could not be installed. This may mean that you have
requested an impossible situation or if you are using the unstable
distribution that some required packages have not yet been created
or been moved out of Incoming.
The following information may help to resolve the situation:

The following packages have unmet dependencies:
 cuda : Depends: cuda-7-5 (= 7.5-18) but it is not going to be installed
 unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                        Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.

He intentado la solución:

1. sudo apt-get remove nvidia-cuda-* # eliminar viejos paquetes de nvidia-cuda

2. Instalar dependencias insatisfechas:

   root@P700-Bruce:/home/bruce/Downloads# apt-get install cuda-7-5
   Reading package lists... Done
   Building dependency tree       
   Reading state information... Done
   Some packages could not be installed. This may mean that you have
   requested an impossible situation or if you are using the unstable
   distribution that some required packages have not yet been created
   or been moved out of Incoming.
   The following information may help to resolve the situation:
   
   The following packages have unmet dependencies:
    cuda-7-5 : Depends: cuda-toolkit-7-5 (= 7.5-18) but it is not going to be installed
               Depends: cuda-runtime-7-5 (= 7.5-18) but it is not going to be installed
    unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                           Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
   E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.
   
   root@P700-Bruce:/home/bruce/Downloads# apt-get install cuda-toolkit-7-5
   Reading package lists... Done
   Building dependency tree       
   Reading state information... Done
   Some packages could not be installed. This may mean that you have
   requested an impossible situation or if you are using the unstable
   distribution that some required packages have not yet been created
   or been moved out of Incoming.
   The following information may help to resolve the situation:
   
   The following packages have unmet dependencies:
    cuda-toolkit-7-5 : Depends: cuda-core-7-5 (= 7.5-18) but it is not going to be installed
                       Depends: cuda-command-line-tools-7-5 (= 7.5-18) but it is not going to be installed
                       Depends: cuda-samples-7-5 (= 7.5-18) but it is not going to be installed
                       Depends: cuda-documentation-7-5 (= 7.5-18) but it is not going to be installed
                       Depends: cuda-visual-tools-7-5 (= 7.5-18) but it is not going to be installed
    unity-control-center : Depends: libcheese-gtk23 (>= 3.4.0) but it is not going to be installed
                           Depends: libcheese7 (>= 3.0.1) but it is not going to be installed
   E: Error, pkgProblemResolver::Resolve generated breaks, this may be caused by held packages.
   

3. Instalar y usar aptitude

Mi sistema operativo Ubuntu14.04 acaba de instalarse y realicé las actualizaciones de software e instalé el último controlador de Nvidia.

¿Me puedes ayudar? ¡Gracias por adelantado!

La instalación de CUDA es un poco complicada. He seguido los siguientes pasos y me funciona. Puede consultar este enlace también.

Confirmación del medio ambiente:

1. lspci | grep -i nvidia (Confirme que se muestra la información de la placa de NVIDIA)

2. uname -m (asegúrese de que sea un x86_64)

3. gcc --version (asegúrese de que esté instalado)

Instalación de CUDA -

1. Descargue el cuda_7.5.18_linux.runarchivo desde https://developer.nvidia.com/cuda-downloads

2. Ejecute los siguientes comandos:

   sudo apt-get install build-essential
   echo blacklist nouveau option nouveau modeset=0 |sudo tee -a /etc/modprobe.d/blacklist-nouveau.conf 
   sudo update-initramfs -u
   

3. Reiniciar la computadora

4. En la pantalla de inicio de sesión, presione Ctrl+ Alt+ F1e inicie sesión con su usuario.

5. Vaya al directorio donde tiene el controlador CUDA y ejecute

   chmod a+x .
   sudo service lightdm stop
   sudo bash cuda-7.5.18_linux.run --no-opengl-libs
   

6. Durante la instalación:

   • Aceptar condiciones de EULA
   • Di SÍ para instalar el controlador NVIDIA
   • Diga SÍ a la instalación de CUDA Toolkit + Driver
   • Diga SÍ a la instalación de muestras de CUDA
   • Di NO al reconstruir las configuraciones de Xserver con Nvidia

7. Comprueba si /dev/nvidia*existen archivos. Si no lo hacen, haga lo siguiente

   sudo modprobe nvidia
   

8. Establecer variables de ruta de entorno

   export PATH=/usr/local/cuda-7.5/bin:$PATH
   export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
   

9. Verifique la versión del controlador

   cat /proc/driver/nvidia/version`
   

10. Verifique la versión del controlador CUDA

    nvcc –V
    

11. Encienda nuevamente el lightdm

    sudo service lightdm start
    

12. Ctrl+ Alt+ F7e inicie sesión en el sistema a través de la GUI

13. Cree muestras de CUDA, vaya a la NVIDIA_CUDA-7.5_Samplescarpeta a través del terminal, luego ejecute el siguiente comando:

    make
    cd bin/x86_64/linux/release/
    ./deviceQuery
    ./bandwidthTest
    

    Ambas pruebas deberían generar un 'PASS' en la terminal

14. Reiniciar el sistema

Hay dos formas de instalar el controlador CUDA adecuado (para Optimus y otros conjuntos de chips gráficos integrados en placas base híbridas): la primera descrita aquí es la más fácil y la segunda descripción es más engorrosa pero efectiva también:

UN)

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt-get update
sudo apt-get install nvidia-355 nvidia-prime
sudo reboot

SI)

La descripción del método B está aquí, pero ya es más antigua (explicado por el usuario dschinn1001): este método B es más humilde y puede ser arriesgado, pero no dañino. :

¿Cómo puedo instalar Nvidia Driver GT 520 y Cuda 5.0 en Ubuntu13.04?

El paquete de controladores beta para que Nvidia se descargue para Linux está aquí:

http://www.nvidia.de/object/cuda_1_1_beta.html

El método A es más simple, pero no está claro, cómo interactúa con xscreensaver y el método B es más antiguo, pero el paquete de controladores también se actualiza en los últimos tiempos, y una vez que se realiza el método B, debería funcionar mejor con xscreensaver condicionado que xscreensaver está instalado (Probé el método B en 13.10 y funcionó muy bien, incluso con xscreensaver. Y creo que el resto de este hilo depende del hardware).

Además y en referencia al abejorro con los conjuntos de chips Optimus-graphics, estos ajustes para el abejorro también son necesarios:

Cómo configurar nVidia Optimus / Bumblebee en 14.04

Suena como lp bug 1428972 .

El usuario fennytansy agregó una solución alternativa en el comentario # 10 :

sudo apt-get install libglew-dev libcheese7 libcheese-gtk23 libclutter-gst-2.0-0 libcogl15 libclutter-gtk-1.0-0 libclutter-1.0-0

Instalé con éxito CUDA usando el método runfile. Es un poco más complicado de configurar porque su controlador de gráficos principal también debe instalarse utilizando el método runfile ( consulte aquí ).

Intente instalar solo el controlador. Esto se puede hacer utilizando el método runfile. Le indicará cada parte de la instalación y puede deshabilitar las GLbibliotecas y los kits de herramientas. El centro de control de la unidad también me ha estado dando problemas debido a la necesidad de la muestra de CUDA de usar en libGLU.solugar de libGL.so. Esta es una solución fácil al crear sus propios ejemplos de aprendizaje.

Intente desinstalar el controlador nvidia e instalar directamente cuda sin él. En un Ubuntu 14.04 nuevo, seguí las instrucciones del sitio web de nvidia . Además de verificar versiones compatibles de cosas (gcc, kernel), las instrucciones fueron:

sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb 
sudo apt-get update
sudo apt-get install cuda 

Afortunadamente, se instaló el controlador nvidia correcto como subproducto de los pasos anteriores.

Pasé un día completo buscando usar " ppa: graphics-drivers / ppa " para actualizar los controladores de NVIDIA a la versión 352. Todo falló. Después de una instalación, gpu-manager.log informó que los controladores se instalaron mientras que Xorg.0.log informaría lo contrario.

El controlador nouveau había sido eliminado y puesto en la lista negra: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf blacklist nouveau options nouveau modeset = 0 alias nouveau off alias lbm-nouveau fuera

Finalmente me di por vencido y usé una solución puramente "NVIDIA ... bin".

1. Nouveau en la lista negra, como se muestra arriba.
2. desinstaló completamente el nouveau Xserver como se citó anteriormente.
3. Configure la BIOS del sistema para que tenga PCIe (las dos tarjetas nvidia) como principal y desactive la interfaz HD4600 de la placa base.
4. arrancado en modo de recuperación, red activada, luego fue al modo de consola.
5. Ejecutó "NVIDIA-Linux-x86_64-352.41.run -uninstall" solo para asegurarse de que no quedara nada.
6. Se eliminó cualquier directorio antiguo en / etc, / usr / local, que parecía un remanente de instalaciones anteriores de cuda o nvidia.
7. Ejecutó "NVIDIA-Linux-x86_64-352.41.run"
8. Ejecutó "NVIDIA-Linux-x86_64-352.41.run --check" para verificar que todo estaba correcto (estaba).
9. Luego ejecutó "cuda_7.5.18_linux.run" para completar la instalación. Las cosas están funcionando actualmente. Ambos monitores están en funcionamiento. Actualmente trabajando en la construcción de los archivos de muestra de Cuda. Asegúrese de utilizar los indicadores "--help" en los contenedores de instalación de NVIDIA. La razón principal por la que decidí ir a la ruta bin (junto con una de las alternativas que no funciona, es que el enfoque "bin" proporciona una ruta fácil para la recuperación después de una actualización OpenGL "mesa".

Reinicié Ubuntu hoy, y descubrí que hay otra dependencia insatisfecha como libcog15 : Depends: mesa-driver...(no recuerdo el nombre completo del paquete), así que solía apt-get installinstalar el "controlador de mesa". Después de eso, CUDA 7.5 se instaló con éxito.

Tenga en cuenta que mi versión de Kernel es 3.19.0-28-generic y la versión de gcc es Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , que no se encuentra en los documentos oficiales de CUDA 7.5 . Comprobaré si realmente funciona.

Intenté sudo su y apt-get install cuda en lugar de sudo apt-get install cuda. Funcionó.

 sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb
 sudo apt-get update
 sudo su
 apt-get install cuda

Consulte: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md . Está relacionado con la instalación de Caffe en esencia, pero también aborda la instalación de CUDA.

-problemas con inicio de sesión lightdm (bucle de inicio de sesión)

-problemas con el controlador istall ("Error de instalación del controlador: parece que se está ejecutando un servidor X ...")

Para instalar con éxito un kit de herramientas NVidia CUDA en Ubuntu 16.04 de 64 bits, solo tuve que hacer:

1. cree una imagen en vivo de Ubuntu en pendrive (un lápiz de 8GB es suficiente): ¡tal intento le ahorrará una tonelada de nervios , antes de una instalación fallida en su sistema Linux host!
2. iniciar sesión en la sesión en vivo en pendrive ("Pruebe Ubuntu, antes de instalar")

3. agregar usuario de sudo en sesión en vivo:

   sudo adduser admin (#pass: admin1)

   sudo usermod -aG sudo admin

4. cerrar sesión de sesión en vivo, iniciar sesión como #admin

5. descargue CUDA Toolkit del sitio oficial de NVidia (~ 1.5GB)

6. cambiar los privilegios para el archivo de instalación descargado (¡NO INSTALE EN ESTE PASO!):
   sudo chmod + x cuda_X.X.run

7. cambiar a la vista de consola:

   Ctr + Alt + F1 (para activar la vista de terminal) Ctr + Alt + F7 (para cambiar de la vista de terminal al servidor gráfico)

8. en la vista de consola (Ctr + Alt + F1) inicie sesión:

   inicio de sesión: admin pass: admin1

9. detener el servicio de ejecución gráfica:

   sudo service lightdm stop

10. compruebe si el servidor gráfico está apagado: después de cambiar Ctr + Alt + F7 el monitor debe estar en blanco negro, vuelva a activar la vista de consola Ctr + Alt + F1

11. instale CUDA Toolkit, con dicha configuración:

    sudo ./cuda_X.X.run (presione 'q' para omitir la lectura de la licencia) no instale la biblioteca OpenGL no actualice la configuración del sistema X otras opciones hacen yes y rutas por defecto

12. encienda el servidor gráfico:

    servicio sudo lightdm start

13. inicie sesión como usuario (si inicia sesión automáticamente como #ubuntu en la sesión en vivo, cierre sesión):

    inicio de sesión: admin pass: admin1

14. verifique cualquier compilador nvcc que funcione con la suma simple de vectores paralelos proporcionada en los bloques GPU

    guarde vecSum.cu y book.h en archivos nuevos, compile y ejecute en la terminal: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

15. compruebe la impresión de la consola: debe ser similar a: 0.000000 + 0.000000 = 0.000000

    -1.100000 + 0.630000 = -0.000000
    
    -2.200000 + 2.520000 = 0.319985
    
    -3.300000 + 5.670000 = 2.119756
    -4.400000 + 10.080000 = 5.679756
    -5.500000 + 15.750000 = 10.250000
    -6.600000 + 22.680000 = 16.017500
    -7.700000 + 30.870001 = 23.170002
    -8.800000 + 40.320000 = 31.519997
    -9.900000 + 51.029999 = 41.129967
    

16. si todo salió bien en la sesión en vivo de pendrive, haz lo mismo en tu sistema Linux

PD: Tenga en cuenta que no es un tutorial ideal, ¡pero funciona bien para mí!

======= vecSum.cu =====

#include "book.h"
#define N 50000
///usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

//"HOST" = CPU
//"Device" = GPU

__global__ void add( float *a, float *b, float *c )
{
    int tid = blockIdx.x;
    if ( tid < N )
        c[ tid ] = a[ tid ] + b[ tid ];
}

int main ( void )
{
    float a[ N ], b[ N ], c[ N ];
    float *dev_a, *dev_b, *dev_c;
    //GPU memory allocation
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_a, N * sizeof( float ) ) );
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_b, N * sizeof( float ) ) );
    HANDLE_ERROR( cudaMalloc( ( void** )&dev_c, N * sizeof( float ) ) );

    //sample input vectors CPU generation
    for ( int i = 0; i < N; i++ )
    {
        a[ i ] = -i * 1.1;
        b[ i ] = i * i * 0.63;
    }

    //copy/load from CPU to GPU data vectors a[], b[] HostToDevice
    HANDLE_ERROR( cudaMemcpy( dev_a, a, N * sizeof( float ), cudaMemcpyHostToDevice ) );
    HANDLE_ERROR( cudaMemcpy( dev_b, b, N * sizeof( float ), cudaMemcpyHostToDevice ) );

    //calculate sum of vectors on GPU
    add<<<N,1>>> ( dev_a, dev_b, dev_c );

    //copy/load result vector from GPU to CPU c[] DeviceToHost
    HANDLE_ERROR( cudaMemcpy( c, dev_c, N * sizeof( float ), cudaMemcpyDeviceToHost ) );

    //printout results
    for ( int i = 0; i < 10; i++ ) printf( "%f + %f = %f\n", a[ i ], b[ i ], c[ i ] );

    //free memory and constructed objects on GPU
    cudaFree( dev_a );
    cudaFree( dev_b );
    cudaFree( dev_c );

    return 0;
}

========= book.h ======

/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */


#ifndef __BOOK_H__
#define __BOOK_H__
#include <stdio.h>

static void HandleError( cudaError_t err,
                         const char *file,
                         int line ) {
    if (err != cudaSuccess) {
        printf( "%s in %s at line %d\n", cudaGetErrorString( err ),
                file, line );
        exit( EXIT_FAILURE );
    }
}
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))


#define HANDLE_NULL( a ) {if (a == NULL) { \
                            printf( "Host memory failed in %s at line %d\n", \
                                    __FILE__, __LINE__ ); \
                            exit( EXIT_FAILURE );}}

template< typename T >
void swap( T& a, T& b ) {
    T t = a;
    a = b;
    b = t;
}


void* big_random_block( int size ) {
    unsigned char *data = (unsigned char*)malloc( size );
    HANDLE_NULL( data );
    for (int i=0; i<size; i++)
        data[i] = rand();

    return data;
}

int* big_random_block_int( int size ) {
    int *data = (int*)malloc( size * sizeof(int) );
    HANDLE_NULL( data );
    for (int i=0; i<size; i++)
        data[i] = rand();

    return data;
}


// a place for common kernels - starts here

__device__ unsigned char value( float n1, float n2, int hue ) {
    if (hue > 360)      hue -= 360;
    else if (hue < 0)   hue += 360;

    if (hue < 60)
        return (unsigned char)(255 * (n1 + (n2-n1)*hue/60));
    if (hue < 180)
        return (unsigned char)(255 * n2);
    if (hue < 240)
        return (unsigned char)(255 * (n1 + (n2-n1)*(240-hue)/60));
    return (unsigned char)(255 * n1);
}

__global__ void float_to_color( unsigned char *optr,
                              const float *outSrc ) {
    // map from threadIdx/BlockIdx to pixel position
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    int offset = x + y * blockDim.x * gridDim.x;

    float l = outSrc[offset];
    float s = 1;
    int h = (180 + (int)(360.0f * outSrc[offset])) % 360;
    float m1, m2;

    if (l <= 0.5f)
        m2 = l * (1 + s);
    else
        m2 = l + s - l * s;
    m1 = 2 * l - m2;

    optr[offset*4 + 0] = value( m1, m2, h+120 );
    optr[offset*4 + 1] = value( m1, m2, h );
    optr[offset*4 + 2] = value( m1, m2, h -120 );
    optr[offset*4 + 3] = 255;
}

__global__ void float_to_color( uchar4 *optr,
                              const float *outSrc ) {
    // map from threadIdx/BlockIdx to pixel position
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    int offset = x + y * blockDim.x * gridDim.x;

    float l = outSrc[offset];
    float s = 1;
    int h = (180 + (int)(360.0f * outSrc[offset])) % 360;
    float m1, m2;

    if (l <= 0.5f)
        m2 = l * (1 + s);
    else
        m2 = l + s - l * s;
    m1 = 2 * l - m2;

    optr[offset].x = value( m1, m2, h+120 );
    optr[offset].y = value( m1, m2, h );
    optr[offset].z = value( m1, m2, h -120 );
    optr[offset].w = 255;
}


#if _WIN32
    //Windows threads.
    #include <windows.h>

    typedef HANDLE CUTThread;
    typedef unsigned (WINAPI *CUT_THREADROUTINE)(void *);

    #define CUT_THREADPROC unsigned WINAPI
    #define  CUT_THREADEND return 0

#else
    //POSIX threads.
    #include <pthread.h>

    typedef pthread_t CUTThread;
    typedef void *(*CUT_THREADROUTINE)(void *);

    #define CUT_THREADPROC void
    #define  CUT_THREADEND
#endif

//Create thread.
CUTThread start_thread( CUT_THREADROUTINE, void *data );

//Wait for thread to finish.
void end_thread( CUTThread thread );

//Destroy thread.
void destroy_thread( CUTThread thread );

//Wait for multiple threads.
void wait_for_threads( const CUTThread *threads, int num );

#if _WIN32
    //Create thread
    CUTThread start_thread(CUT_THREADROUTINE func, void *data){
        return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, data, 0, NULL);
    }

    //Wait for thread to finish
    void end_thread(CUTThread thread){
        WaitForSingleObject(thread, INFINITE);
        CloseHandle(thread);
    }

    //Destroy thread
    void destroy_thread( CUTThread thread ){
        TerminateThread(thread, 0);
        CloseHandle(thread);
    }

    //Wait for multiple threads
    void wait_for_threads(const CUTThread * threads, int num){
        WaitForMultipleObjects(num, threads, true, INFINITE);

        for(int i = 0; i < num; i++)
            CloseHandle(threads[i]);
    }

#else
    //Create thread
    CUTThread start_thread(CUT_THREADROUTINE func, void * data){
        pthread_t thread;
        pthread_create(&thread, NULL, func, data);
        return thread;
    }

    //Wait for thread to finish
    void end_thread(CUTThread thread){
        pthread_join(thread, NULL);
    }

    //Destroy thread
    void destroy_thread( CUTThread thread ){
        pthread_cancel(thread);
    }

    //Wait for multiple threads
    void wait_for_threads(const CUTThread * threads, int num){
        for(int i = 0; i < num; i++)
            end_thread( threads[i] );
    }

#endif




#endif  // __BOOK_H__