Ma station de travail a deux GPU (Quadro K5200 et Quadro K2200) avec le dernier pilote NVIDIA installé (Version: 352.41). Après avoir téléchargé le fichier à cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debpartir des téléchargements de CUDA 7.5 , j'essaie de l'installer, mais le résultat est le suivant:

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.

J'ai essayé la solution:

1. sudo apt-get remove nvidia-cuda-* # supprimer les anciens packages nvidia-cuda

2. Installez les dépendances non satisfaites:

   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. Installer et utiliser aptitude

Mon système d'exploitation Ubuntu14.04 vient d'être installé et a effectué les mises à jour logicielles et installé le dernier pilote Nvidia.

Pouvez-vous m'aider? Merci d'avance!

L'installation de CUDA est un peu délicate. J'ai suivi les étapes suivantes et cela fonctionne pour moi. Vous pouvez également consulter ce lien .

Confirmation de l'environnement:

1. lspci | grep -i nvidia (Confirmez que les informations de la carte NVIDIA sont affichées)

2. uname -m (assurez-vous qu'il s'agit d'un x86_64)

3. gcc --version (assurez-vous qu'il est installé)

Installation de CUDA -

1. Téléchargez le cuda_7.5.18_linux.runfichier depuis https://developer.nvidia.com/cuda-downloads

2. Exécutez les commandes suivantes:

   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. Redémarrer l'ordinateur

4. À l'écran de connexion, appuyez sur Ctrl+ Alt+ F1et connectez-vous à votre utilisateur.

5. Accédez au répertoire où vous avez le pilote CUDA et exécutez

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

6. Pendant l'installation:

   • Accepter les conditions du CLUF
   • Dites OUI à l'installation du pilote NVIDIA
   • Dites OUI à l'installation de CUDA Toolkit + Driver
   • Dites OUI à l'installation des échantillons CUDA
   • Dites NON reconstruire les configurations Xserver avec Nvidia

7. Vérifiez si des /dev/nvidia*fichiers existent. Si ce n'est pas le cas, procédez comme suit

   sudo modprobe nvidia
   

8. Définir les variables de chemin d'accès à l'environnement

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

9. Vérifiez la version du pilote

   cat /proc/driver/nvidia/version`
   

10. Vérifier la version du pilote CUDA

    nvcc –V
    

11. Rallumez le lightdm à nouveau

    sudo service lightdm start
    

12. Ctrl+ Alt+ F7et connectez-vous au système via GUI

13. Créez des échantillons CUDA, accédez au NVIDIA_CUDA-7.5_Samplesdossier via le terminal, puis exécutez la commande suivante:

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

    Les deux tests devraient finalement produire un «PASS» dans le terminal

14. Redémarrez le système

Il existe deux façons d'installer un pilote CUDA adapté (pour Optimus et autres chipsets graphiques intégrés sur les cartes mères hybrides) - la première décrite ici est la plus simple et la seconde est plus lourde mais aussi efficace:

UNE)

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

B)

La description de la méthode B est ici, mais déjà plus ancienne (expliquée par l'utilisateur dschinn1001) - cette méthode B est plus humble et peut être risquée, mais pas nuisible. :

Comment puis-je installer Nvidia Driver GT 520 et Cuda 5.0 dans Ubuntu13.04?

Le package bêta-pilote pour Nvidia à télécharger pour Linux est ici:

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

La méthode A est plus simple, mais pas claire, comment elle interagit avec xscreensaver et la méthode B est plus ancienne, mais le package de pilotes est également mis à jour récemment, et après la méthode B, cela devrait mieux fonctionner avec xscreensaver condition que xscreensaver soit installée. (J'ai testé la méthode B le 13.10 et cela fonctionnait très bien, même avec xscreensaver. Et je pense que le reste de ce fil dépend du matériel.)

De plus et en référence au bourdon avec les chipsets graphiques Optimus, ces ajustements pour le bourdon sont également nécessaires:

Comment configurer nVidia Optimus / Bumblebee en 14.04

Cela ressemble au bug lp 1428972 .

L'utilisateur fennytansy a ajouté une solution de contournement dans le commentaire # 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

J'ai installé CUDA avec succès en utilisant la méthode runfile. La configuration est un peu plus délicate car votre pilote graphique principal doit également être installé à l'aide de la méthode runfile ( voir ici ).

Essayez d'installer uniquement le pilote. Cela peut être fait en utilisant la méthode runfile. Il vous demandera pour chaque partie de l'installation et vous pouvez désactiver les GLbibliothèques et les kits d'outils. Le centre de contrôle de l'unité m'a également posé des problèmes en raison du besoin de l'échantillon CUDA d'utiliser à la libGLU.soplace de libGL.so. Il s'agit d'une solution simple lorsque vous créez vos propres exemples d'apprentissage.

Essayez de désinstaller le pilote nvidia et d'installer directement cuda sans lui. Sur un nouveau Ubuntu 14.04, j'ai suivi les instructions du site nvidia . En plus de vérifier les versions compatibles des choses (gcc, noyau), les instructions étaient les suivantes:

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

Heureusement, le pilote nvidia correct a été installé en tant que sous-produit des étapes ci-dessus.

J'ai passé une journée entière à chercher à utiliser " ppa: graphics-drivers / ppa " pour mettre à jour les pilotes NVIDIA vers la version 352. Tout a échoué. Après une installation, le gpu-manager.log a signalé que les pilotes ont été installés tandis que Xorg.0.log signalerait le contraire.

Le pilote nouveau a été supprimé et mis sur liste noire: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf blacklist nouvelles options nouveau modeset = 0 alias nouveau off alias lbm-nouveau désactivé

J'ai finalement abandonné et utilisé une solution purement "NVIDIA ... bin".

1. Nouveau sur liste noire, comme indiqué ci-dessus.
2. complètement désinstallé le nouveau Xserver comme indiqué ci-dessus.
3. Configurez le système bios pour avoir PCIe (les deux cartes nvidia) comme principal et désactivez l'interface de la carte mère HD4600.
4. démarré en mode de récupération, activé le réseau, puis est passé en mode console.
5. Exécutez "NVIDIA-Linux-x86_64-352.41.run -uninstall" juste pour vous assurer qu'il ne reste rien.
6. Supprimé tous les anciens répertoires de / etc, / usr / local, qui ressemblaient à des restes d'installations cuda ou nvidia antérieures.
7. A exécuté "NVIDIA-Linux-x86_64-352.41.run"
8. A lancé "NVIDIA-Linux-x86_64-352.41.run --check" pour vérifier que tout était correct (il l'était).
9. Exécutez ensuite "cuda_7.5.18_linux.run" pour terminer l'installation. Les choses fonctionnent actuellement. Les deux moniteurs sont en place et fonctionnent. Travaille actuellement sur la construction des fichiers d'exemple cuda. Assurez-vous d'utiliser les indicateurs "--help" sur les bacs d'installation NVIDIA. La principale raison pour laquelle j'ai décidé d'opter pour la route bin (avec l'une des alternatives qui ne fonctionne pas, c'est que l'approche "bin" fournit une route facile vers la récupération après une mise à jour OpenGL "mesa".

J'ai redémarré Ubuntu aujourd'hui, et j'ai trouvé qu'il y avait une autre dépendance non satisfaite quelque chose comme libcog15 : Depends: mesa-driver...(je ne me souviens pas du nom complet du paquet), j'ai donc utilisé apt-get installpour installer le "mesa-driver". Après cela, CUDA 7.5 s'est installé avec succès.

Notez que ma version du noyau est 3.19.0-28-générique et la version gcc est Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , qui ne se trouve pas dans les documents officiels de CUDA 7.5 . Je vais vérifier si ça marche vraiment.

J'ai essayé sudo su et apt-get install cuda au lieu de sudo apt-get install cuda. Ça a marché.

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

Veuillez vous référer à: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md . Il est essentiellement lié à l'installation de Caffe, mais il concerne également l'installation de CUDA.

-problems avec connexion lightdm (boucle de connexion)

-problèmes avec le pilote istall ("Échec de l'installation du pilote: il semble qu'un serveur X fonctionne ...")

Pour installer avec succès une boîte à outils NVidia CUDA sur Ubuntu 16.04 64 bits, je dois juste faire:

1. faire une image en direct d'Ubuntu sur clé USB (un stylo de 8 Go suffit) - un tel essai vous fera économiser une tonne de nerfs , avant une installation infructueuse sur votre système Linux hôte !!!
2. connectez-vous en session en direct sur pendrive ("Essayez Ubuntu, avant l'installation")

3. ajouter un utilisateur sudo lors d'une session en direct:

   sudo adduser admin (#pass: admin1)

   sudo usermod -aG sudo admin

4. déconnectez-vous de la session en direct, connectez-vous en tant que #admin

5. télécharger CUDA Toolkit depuis le site officiel de NVidia (~ 1,5 Go)

6. changer les privilèges pour le fichier d'installation téléchargé (NE PAS INSTALLER À CETTE ÉTAPE!):
   sudo chmod + x cuda_X.X.run

7. passer en vue console:

   Ctr + Alt + F1 (pour activer la vue du terminal) Ctr + Alt + F7 (pour passer de la vue du terminal au serveur graphique)

8. dans la vue console (Ctr + Alt + F1), connectez-vous:

   connexion: admin passe: admin1

9. arrêter le service d'exécution graphique:

   sudo service lightdm stop

10. vérifier si le serveur graphique est éteint - après avoir changé Ctr + Alt + F7, le moniteur doit être noir vierge, revenir en mode console Ctr + Alt + F1

11. installez CUDA Toolkit, avec une telle configuration:

    sudo ./cuda_X.X.run (appuyez sur 'q' pour le saut de lecture de licence) n'installez pas la bibliothèque OpenGL ne mettez pas à jour la configuration du système X d'autres options font oui et les chemins par défaut

12. activer le serveur graphique:

    sudo service lightdm start

13. connectez-vous en tant qu'utilisateur (si vous vous connectez automatiquement en tant que #ubuntu lors de la déconnexion de la session en direct):

    connexion: admin passe: admin1

14. vérifiez ce que le compilateur nvcc fonctionne avec la somme vectorielle parallèle simple fournie aux blocs GPU:

    enregistrer vecSum.cu et book.h dans de nouveaux fichiers, compiler et exécuter sur le terminal: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

15. vérifier l'impression de la console - elle devrait être similaire à: 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 tout s'est bien passé sur la session live pendrive, faites de même sur votre système Linux hôte

PS Veuillez noter que ce n'est pas un tutoriel idéal, mais fonctionne très bien pour moi!

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