Qualcuno ha installato con successo CUDA 7.5 su Ubuntu 14.04.3 LTS x86_64?

12

La mia workstation ha due GPU (Quadro K5200 e Quadro K2200) con l'ultimo driver NVIDIA installato (Versione: 352.41). Dopo aver scaricato il file cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.deb da download CUDA 7.5 , provo a installarlo, ma risulta il risultato come sotto :

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.

Ho provato la soluzione:

  1. sudo apt-get remove nvidia-cuda-* # rimuove i vecchi pacchetti nvidia-cuda
  2. Installa dipendenze non soddisfatte:

    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. Installa e utilizza aptitude

Il mio sistema operativo Ubuntu14.04 è appena installato e ho effettuato gli aggiornamenti del software e installato l'ultimo driver Nvidia.

Puoi dare un aiuto? Grazie in anticipo!

    
posta Bruce Yo 09.09.2015 - 11:58
fonte

10 risposte

1

Ho riavviato Ubuntu oggi, e ho scoperto che c'è un'altra dipendenza insoddisfatta, come libcog15 : Depends: mesa-driver... (non ricordo il nome completo del pacchetto), quindi ho usato apt-get install per installare il "mesa-driver". Successivamente, CUDA 7.5 è stato installato con successo.

Si noti che la mia versione del kernel è 3.19.0-28-generica e la versione gcc è Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , che non si trova in < a href="http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#ubuntu-installation"> documenti ufficiali CUDA 7.5 . Controllerò se funziona davvero.

    
risposta data Bruce Yo 10.09.2015 - 03:50
fonte
8

L'installazione di CUDA è un po 'complicata. Ho seguito i seguenti passaggi e funziona per me. Puoi fare riferimento a questo link anche.

Conferma dell'ambiente:

  1. lspci | grep -i nvidia (Confermare che vengano visualizzate le informazioni della scheda NVIDIA)

  2. uname -m (assicurati che sia un x86_64)

  3. gcc --version (assicurati che sia installato)

Installazione di CUDA -

  1. Scarica cuda_7.5.18_linux.run file da link

  2. Esegui i seguenti comandi:

    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. Riavvia il computer

  4. Nella schermata di accesso, premi Ctrl + Alt + F1 e accedi al tuo utente.

  5. Vai alla directory in cui è presente il driver CUDA ed esegui

    chmod a+x .
    sudo service lightdm stop
    sudo bash cuda-7.5.18_linux.run --no-opengl-libs
    
  6. Durante l'installazione:

    • Accetta le condizioni EULA
    • Dì SÌ all'installazione del driver NVIDIA
    • Pronuncia SÌ per installare CUDA Toolkit + Driver
    • Dì SÌ all'installazione di CUDA Samples
    • Dire NO che ricostruisce le configurazioni di Xserver con Nvidia
  7. Verifica se esistono file /dev/nvidia* . Se non lo fanno, fai quanto segue

    sudo modprobe nvidia
    
  8. Imposta variabili percorso ambiente

    export PATH=/usr/local/cuda-7.5/bin:$PATH
    export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
    
  9. Verifica la versione del driver

    cat /proc/driver/nvidia/version'
    
  10. Verifica la versione del driver CUDA

    nvcc –V
    
  11. Riaccendi il lightdm

    sudo service lightdm start
    
  12. Ctrl + Alt + F7 e accedi al sistema tramite la GUI

  13. Crea esempi CUDA, vai alla cartella NVIDIA_CUDA-7.5_Samples tramite terminale, quindi esegui il seguente comando:

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

    Entrambi i test dovrebbero in definitiva produrre un 'PASS' nel terminale

  14. Riavvia il sistema

risposta data Avik 19.02.2016 - 05:38
fonte
2

Ci sono due modi per installare il CUDA-driver adatto (per Optimus e altri chipset grafici integrati su mainboard ibride) - il primo qui descritto è il più semplice e la seconda descrizione è più ingombrante ma anche efficace:

A)

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

B)

La descrizione del metodo B è qui, ma già precedente (spiegato dall'utente dschinn1001) - questo metodo B è più umiliante e può essere rischioso, ma non dannoso. :

Come posso installare Nvidia Driver GT 520 e Cuda 5.0 in Ubuntu13.04?

Il pacchetto beta-driver per Nvidia da scaricare per Linux è qui:

link

Il metodo A è più semplice, ma non chiaro, in che modo interagisce con xscreensaver e il metodo B è più vecchio, ma il pacchetto driver viene aggiornato anche negli ultimi tempi e, dopo aver eseguito il metodo B, dovrebbe funzionare meglio con xscreensaver condizionato che xscreensaver è installato. (Ho provato il metodo B in 13.10 e questo funzionava molto bene, anche con xscreensaver e penso che il resto di questo thread sia all'altezza dell'hardware.)

Inoltre, in riferimento a bumblebee con i chipset di Optimus-graphics, sono necessari anche questi adattamenti per bumblebee:

Come configurare nVidia Optimus / Bumblebee in 14.04

    
risposta data dschinn1001 21.09.2015 - 21:19
fonte
1

Sembra lp bug 1428972 .

Utente fennytansy ha aggiunto una soluzione alternativa in commento # 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

    
risposta data user3813819 10.09.2015 - 01:37
fonte
1

Ho installato CUDA con successo usando il metodo runfile. È un po 'complicato da configurare perché il tuo driver di grafica principale deve essere installato usando il metodo runfile ( Vedi qui ).

Prova ad installare solo il driver. Questo può essere fatto usando il metodo runfile. Ti verrà richiesto per ogni parte dell'installazione e potrai disabilitare le librerie e i toolkit GL . Il centro di controllo dell'unità mi ha dato problemi anche a causa dell'esigenza del campione CUDA di utilizzare libGLU.so anziché libGL.so . Questa è una soluzione semplice quando si costruiscono i propri esempi di apprendimento.

    
risposta data asdf 15.09.2015 - 20:35
fonte
1

Prova a disinstallare il driver nvidia e installa direttamente cuda senza di esso. Su una nuova Ubuntu 14.04, ho seguito le istruzioni dal sito web nvidia . A parte la verifica delle versioni compatibili di cose (gcc, kernel), le istruzioni erano:

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

Fortunatamente, il driver nvidia corretto è stato installato come sottoprodotto dei passaggi precedenti.

    
risposta data 661266 25.09.2015 - 01:46
fonte
1

Ho trascorso un'intera giornata cercando di utilizzare " ppa: graphics-drivers / ppa " per aggiornare NVIDIA i driver alla versione 352. Tutto fallito. Dopo un'installazione, gpu-manager.log ha segnalato che i driver sono stati installati mentre Xorg.0.log avrebbe riportato il contrario.

Il driver nouveau era stato rimosso e inserito nella blacklist:      sudo apt-get --purge rimuovi xserver-xorg-video-nouveau      cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf         lista nera         options nouveau modeset = 0         alias nouveau off         alias lbm-nouveau off

Alla fine ho rinunciato e ho usato una soluzione puramente "NVIDIA ... bin".

  1. Nuovo elenco in black list, come mostrato sopra.
  2. completamente disinstallato il nouveau Xserver come citato sopra.
  3. Imposta il BIOS di sistema per avere PCIe (le due schede nvidia) come principale e disattivare l'interfaccia HD4600 della scheda madre.
  4. avviato in modalità di ripristino, rete attivata, quindi in modalità console.
  5. Esegui "NVIDIA-Linux-x86_64-352.41.run -uninstall" solo per assicurarsi che non sia rimasto nulla.
  6. Eliminato qualsiasi vecchia directory in / etc, / usr / local, che sembrava un residuo delle passate installazioni di cuda o nvidia.
  7. Ran "NVIDIA-Linux-x86_64-352.41.run"
  8. Ran "NVIDIA-Linux-x86_64-352.41.run --check" per verificare che tutto fosse corretto (lo era).
  9. Quindi è stato eseguito "cuda_7.5.18_linux.run" per completare l'installazione. Le cose stanno funzionando al momento. Entrambi i monitor sono attivi e funzionanti. Attualmente sto lavorando alla creazione dei file di esempio cuda. Assicurarsi di utilizzare i flag "--help" sui contenitori di installazione di NVIDIA. Il motivo principale per cui ho deciso di seguire il percorso del cestino (insieme a una delle alternative che non funzionano, è che l'approccio "bin" fornisce un facile percorso per il recupero dopo un aggiornamento OpenGL "mesa".
risposta data user225932 18.09.2015 - 19:05
fonte
0

Si prega di fare riferimento a: link . È collegato all'installazione di Caffe in essenza, ma riguarda anche l'installazione CUDA.

    
risposta data amirsina torfi 27.10.2016 - 08:53
fonte
-1

Ho provato sudo su e apt-get install cuda invece di sudo apt-get install cuda. Ha funzionato.

 sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb
 sudo apt-get update
 sudo su
 apt-get install cuda
    
risposta data softgearko 05.02.2016 - 03:54
fonte
-1

-problemi con lightdm accedi (login loop)

- problemi con il driver istall ("Installazione driver fallita: sembra che un server X sia in esecuzione ...")

Per installare con successo un NVIDIA CUDA Toolkit su Ubuntu 16.04 a 64 bit ho appena dovuto fare:

  1. crea un liveImage di Ubuntu su pendrive (è sufficiente una penna da 8 GB) - un tale tentativo salverà un sacco di nervi , prima di fallire installa sul tuo sistema Linux host !!!
  2. accedi alla sessione live su pendrive ("Prova Ubuntu, prima di installare" )
  3. aggiungi utente sudo alla sessione live:

    sudo adduser admin (#pass: admin1)

    sudo usermod -aG sudo admin

  4. disconnetti dalla sessione live, accedi come #admin

  5. scarica CUDA Toolkit dal sito ufficiale NVidia (~ 1.5GB)
  6. modifica dei privilegi per il file di installazione scaricato (NON INSTALLARE A QUESTO PASSO! ):
    sudo chmod + x cuda_X.X.run

  7. passa alla visualizzazione della console:

    Ctr + Alt + F1 (per attivare la vista terminale) Ctr + Alt + F7 (per passare dalla vista terminale al server grafico)

  8. alla vista della console (Ctr + Alt + F1) accedi:

    login: admin pass: admin1

  9. interrompe il servizio di gestione grafica:

    sudo service lightdm stop

  10. controlla se il server grafico è spento - dopo aver cambiato Ctr + Alt + F7  il monitor dovrebbe essere nero vuoto, tornare alla vista console  Ctr + Alt + F1

  11. installa CUDA Toolkit, con tale configurazione:

    sudo ./cuda_X.X.run (premere 'q' per leggere la lettura salta) non installare la libreria OpenGL non aggiornare la configurazione del sistema X. altre opzioni rendono yes e path come default

  12. attiva il server grafico:

    sudo service lightdm start

  13. accedi come utente (se accedi automaticamente come #ubuntu dal vivo  sessione di log out):

    login: admin pass: admin1

  14. controlla qualsiasi cosa il compilatore nvcc funzioni con il semplice fornito  somma vettoriale parallela a blocchi GPU:

    salva vecSum.cu e prenota.h nei nuovi file, compila ed esegui al terminale: /usr/local/cuda-8.0/bin/nvcc vecSum.cu & amp; & amp; chiaro & amp; & amp; ./a.out

  15. controlla la stampa della console - dovrebbe essere simile 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 tutto è andato bene durante la sessione live di Pendrive, fai lo stesso sul sistema Linux host

P.S. Si prega di notare che non è un tutorial ideale, ma funziona perfettamente per me!

======= 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__
    
risposta data Piotr Lenarczyk 18.10.2016 - 11:15
fonte

Leggi altre domande sui tag