Minha estação de trabalho possui duas GPUs (Quadro K5200 e Quadro K2200) com o driver NVIDIA mais recente instalado (Versão: 352.41). Depois de baixar o arquivo cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debdo CUDA 7.5 Downloads , tento instalá-lo, mas o resultado é o seguinte:

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.

Eu tentei a solução:

1. sudo apt-get remove nvidia-cuda-* # remover pacotes antigos da nvidia-cuda

2. Instale dependências não atendidas:

   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. Instale e use o aptitude

Meu sistema operacional Ubuntu14.04 acabou de instalar e atualizou o software e instalou o driver mais recente da Nvidia.

Você pode dar alguma ajuda? Desde já, obrigado!

A instalação do CUDA é um pouco complicada. Eu segui os seguintes passos e funciona para mim. Você pode consultar este link também.

Confirmação do meio ambiente:

1. lspci | grep -i nvidia (Confirme se as informações da placa da NVIDIA são exibidas)

2. uname -m (verifique se é um x86_64)

3. gcc --version (verifique se está instalado)

Instalação do CUDA -

1. Faça cuda_7.5.18_linux.runo download do arquivo em https://developer.nvidia.com/cuda-downloads

2. Execute os seguintes 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. Reinicie o computador

4. Na tela de login, pressione Ctrl+ Alt+ F1e faça login no seu usuário.

5. Vá para o diretório em que você possui o driver CUDA e execute

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

6. Durante a instalação:

   • Aceitar condições do EULA
   • Diga SIM para instalar o driver NVIDIA
   • Diga SIM para instalar o CUDA Toolkit + Driver
   • Diga SIM para instalar amostras CUDA
   • Diga NÃO reconstruindo nenhuma configuração do Xserver com a Nvidia

7. Verifique se /dev/nvidia*existem arquivos. Caso contrário, faça o seguinte

   sudo modprobe nvidia
   

8. Definir variáveis ​​de caminho do ambiente

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

9. Verifique a versão do driver

   cat /proc/driver/nvidia/version`
   

10. Verifique a versão do driver CUDA

    nvcc –V
    

11. Ligue novamente o lightdm

    sudo service lightdm start
    

12. Ctrl+ Alt+ F7e faça login no sistema através da GUI

13. Crie amostras CUDA, vá para a NVIDIA_CUDA-7.5_Samplespasta através do terminal e execute o seguinte comando:

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

    Ambos os testes devem emitir um 'PASS' no terminal

14. Reinicie o sistema

Existem duas maneiras de instalar o driver CUDA adequado (para Optimus e outros chipsets gráficos integrados em placas-mãe híbridas) - a primeira descrita aqui é a mais fácil e a segunda descrição é mais complicada, mas eficaz:

A)

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

B)

A descrição do método B está aqui, mas já é mais antiga (explicada pelo usuário dschinn1001) - esse método B é mais humilde e pode ser arriscado, mas não prejudicial. :

Como instalar o Nvidia Driver GT 520 e Cuda 5.0 no Ubuntu13.04?

O pacote beta-driver para a Nvidia fazer o download para Linux está aqui:

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

O método A é mais simples, mas não claro, como ele interage com o xscreensaver e o método B é mais antigo, mas o pacote de drivers também é atualizado recentemente, e após a conclusão do método B, ele deve funcionar melhor com o xscreensaver, com a condição de que o xscreensaver seja instalado. (Testei o método B na 13.10 e isso estava funcionando muito bem, mesmo com o xscreensaver. E acho que o restante desse segmento depende do hardware.)

Além disso, e em referência ao zangão com os chipsets Optimus-Graphics, esses ajustes também são necessários:

Como instalar o nVidia Optimus / Bumblebee na versão 14.04

Soa como o bug lp 1428972 .

O usuário fennytansy adicionou uma solução alternativa no comentário # 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

Instalei com êxito o CUDA usando o método runfile. É um pouco mais complicado de configurar porque o driver gráfico principal também deve ser instalado usando o método runfile ( consulte aqui ).

Tente instalar apenas o driver. Isso pode ser feito usando o método runfile. Ele solicitará cada parte da instalação e você poderá desativar as GLbibliotecas e kits de ferramentas. O centro de controle da unidade também me deu problemas devido à necessidade de usar a amostra CUDA em libGLU.sovez de libGL.so. Essa é uma solução fácil ao criar seus próprios exemplos de aprendizado.

Tente desinstalar o driver da nvidia e instalar diretamente o cuda sem ele. Em um novo Ubuntu 14.04, segui as instruções do site da nvidia . Além de verificar versões compatíveis das coisas (gcc, kernel), as instruções foram:

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

Felizmente, o driver nvidia correto foi instalado como subproduto das etapas acima.

Passei um dia inteiro procurando usar " ppa: graphics-drivers / ppa " para atualizar os drivers da NVIDIA para a versão 352. Tudo falhou. Após uma instalação, o gpu-manager.log relatou que os drivers foram instalados enquanto o Xorg.0.log relatou o contrário.

O driver do nouveau foi removido e colocado na lista negra: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf lbm-nouveau off

Finalmente desisti e usei uma solução puramente "NVIDIA ... bin".

1. Nouveau na lista negra, como mostrado acima.
2. desinstalou completamente o nouveau Xserver como citado acima.
3. Defina a BIOS do sistema para ter o PCIe (as duas placas nvidia) como principal e desativou a interface HD4600 da placa principal.
4. inicializado no modo de recuperação, rede ativada e depois foi para o modo console.
5. Executei "NVIDIA-Linux-x86_64-352.41.run -uninstall" apenas para garantir que não sobrou nada.
6. Excluídos os diretórios antigos em / etc, / usr / local, que pareciam um remanescente de instalações anteriores de cuda ou nvidia.
7. Ran "NVIDIA-Linux-x86_64-352.41.run"
8. Execute "NVIDIA-Linux-x86_64-352.41.run --check" para verificar se tudo estava correto (estava).
9. Em seguida, execute "cuda_7.5.18_linux.run" para concluir a instalação. As coisas estão funcionando no momento. Ambos os monitores estão funcionando. Atualmente trabalhando na construção dos arquivos de amostra cuda. Certifique-se de usar os sinalizadores "--help" nos compartimentos de instalação da NVIDIA. A principal razão pela qual eu decidi seguir a rota do bin (juntamente com uma das alternativas que não está funcionando) é que a abordagem "bin" fornece um caminho fácil para a recuperação após uma atualização do OpenGL "mesa".

Reiniciei o Ubuntu hoje e descobri que há outra dependência não atendida, algo como libcog15 : Depends: mesa-driver...(não me lembro o nome completo do pacote), então useiapt-get install instalar o "mesa-driver". Depois disso, o CUDA 7.5 foi instalado com sucesso.

Observe que minha versão do Kernel é 3.19.0-28-genérica e a versão do gcc é o Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , que não é encontrado nos documentos oficiais do CUDA 7.5 . Vou verificar se realmente funciona.

Eu tentei o sudo su e o apt-get install cuda em vez do sudo apt-get install cuda. Funcionou.

 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 à instalação do Caffe em essência, mas também trata da instalação do CUDA.

-problemas com o log do lightdm (loop de login)

-problemas com o driver istall ("Falha na instalação do driver: parece que um servidor X está executando ...")

Para instalar com sucesso um NVidia CUDA Toolkit no Ubuntu 16.04 64bit, acabei de fazer:

1. faça uma imagem ao vivo do Ubuntu no pendrive (caneta de 8 GB é suficiente) - essa tentativa economizará uma tonelada de nervos antes da instalação malsucedida no sistema Linux host !!!
2. faça login na sessão ao vivo no pendrive ("Experimente o Ubuntu, antes de instalar")

3. adicione usuário sudo na sessão ao vivo:

   sudo adduser admin (#pass: admin1)

   sudo usermod -aG sudo admin

4. sair da sessão ao vivo, faça login como #admin

5. baixe o CUDA Toolkit no site oficial da NVidia (~ 1.5GB)

6. alterar privilégios para o arquivo do instalador baixado (NÃO INSTALE NESTA ETAPA!):
   sudo chmod + x cuda_X.X.run

7. alterne para a visualização do console:

   Ctr + Alt + F1 (para ativar a visualização do terminal) Ctr + Alt + F7 (para alternar da visualização do terminal para o servidor gráfico)

8. na visualização do console (Ctr + Alt + F1), faça o login:

   login: senha do administrador: admin1

9. interrompa o serviço de execução gráfica:

   serviço sudo lightdm stop

10. verifique se o servidor gráfico está desligado - após alternar Ctr + Alt + F7, o monitor deve ficar preto em branco, volte para a exibição do console Ctr + Alt + F1

11. instale o CUDA Toolkit, com essa configuração:

    sudo ./cuda_X.X.run (pressione 'q' para ignorar a leitura da licença) não instala a biblioteca OpenGL, não atualiza a configuração do sistema X, outras opções tornam yes e os caminhos como padrão

12. ative o servidor gráfico:

    serviço sudo lightdm start

13. faça login como usuário (se você fizer login automaticamente como #ubuntu na sessão ao vivo, faça logout):

    login: senha do administrador: admin1

14. verifique o que o compilador nvcc trabalha com a soma vetorial paralela simples fornecida nos blocos GPU:

    salve vecSum.cu e book.h em novos arquivos, compile e execute no terminal: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

15. verifique a impressão do console - deve ser semelhante 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. se tudo correu bem na sessão ao vivo do pendrive, faça o mesmo no sistema Linux host

PS Por favor, note que não é o tutorial ideal, mas funciona bem para mim!

======= 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__