Moja stacja robocza ma dwa procesory graficzne (Quadro K5200 i Quadro K2200) z zainstalowanym najnowszym sterownikiem NVIDIA (wersja: 352.41). Po pobraniu pliku cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.debz CUDA 7.5 do pobrania próbuję go zainstalować, ale okazuje się, że wynik jest następujący:

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.

Wypróbowałem rozwiązanie:

1. sudo apt-get remove nvidia-cuda-* # usuń stare pakiety nvidia-cuda

2. Zainstaluj niespełnione zależności:

   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. Zainstaluj i użyj aptitude

Mój system operacyjny Ubuntu14.04 został właśnie zainstalowany, dokonałem aktualizacji oprogramowania i zainstalowałem najnowszy sterownik Nvidia.

Czy możesz mi pomóc? Z góry dziękuję!

Instalacja CUDA jest nieco trudna. Wykonałem następujące kroki i to działa dla mnie. Możesz również skorzystać z tego linku .

Potwierdzenie środowiska:

1. lspci | grep -i nvidia (Potwierdź, że wyświetlana jest informacja o płycie NVIDIA)

2. uname -m (upewnij się, że jest to x86_64)

3. gcc --version (upewnij się, że jest zainstalowany)

Instalacja CUDA -

1. Pobierz cuda_7.5.18_linux.runplik z https://developer.nvidia.com/cuda-downloads

2. Uruchom następujące polecenia:

   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. Restart komputera

4. Na ekranie logowania naciśnij Ctrl+ Alt+ F1i zaloguj się do użytkownika.

5. Przejdź do katalogu, w którym masz sterownik CUDA, i uruchom

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

6. Podczas instalacji:

   • Zaakceptuj warunki umowy EULA
   • Powiedz TAK, aby zainstalować sterownik NVIDIA
   • Powiedz TAK, aby zainstalować CUDA Toolkit + Driver
   • Powiedz TAK, aby zainstalować próbki CUDA
   • Powiedz „NIE” odbudowuj konfiguracji Xserver za pomocą Nvidii

7. Sprawdź, czy /dev/nvidia*istnieją pliki. Jeśli nie, wykonaj następujące czynności

   sudo modprobe nvidia
   

8. Ustaw zmienne ścieżki środowiska

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

9. Sprawdź wersję sterownika

   cat /proc/driver/nvidia/version`
   

10. Sprawdź wersję sterownika CUDA

    nvcc –V
    

11. Ponownie włącz lightdm

    sudo service lightdm start
    

12. Ctrl+ Alt+ F7i zaloguj się do systemu za pomocą GUI

13. Utwórz próbki CUDA, przejdź do NVIDIA_CUDA-7.5_Samplesfolderu przez terminal, a następnie uruchom następujące polecenie:

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

    Oba testy powinny ostatecznie wygenerować „PASS” w terminalu

14. Uruchom ponownie system

Istnieją dwa sposoby instalacji odpowiedniego sterownika CUDA (dla Optimusa i innych wbudowanych układów graficznych na hybrydowych płytach głównych) - pierwszy opisany tutaj jest najłatwiejszy, a drugi opis jest bardziej skomplikowany, ale także skuteczny:

ZA)

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

B)

Opis metody B jest tutaj, ale już starszy (wyjaśniony przez użytkownika dschinn1001) - ta metoda B jest bardziej skromna i może być ryzykowna, ale nieszkodliwa. :

Jak mogę zainstalować Nvidia Driver GT 520 i Cuda 5.0 w Ubuntu13.04?

Pakiet sterowników beta dla Nvidii do pobrania na Linuksa znajduje się tutaj:

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

Metoda A jest prostsza, ale niejasna, w jaki sposób współdziała z programem xscreensaver, a metoda B jest starsza, ale pakiet sterowników został również zaktualizowany w ostatnim czasie, a po wykonaniu metody B powinien działać lepiej z xscreensaver, pod warunkiem, że xscreensaver jest zainstalowany. (Testowałem metodę B na 13.10 i to działało bardzo dobrze, nawet z xscreensaver. I myślę, że reszta tego wątku zależy od sprzętu.)

Oprócz tego, w odniesieniu do trzmiela z chipsetami graficznymi Optimus, konieczne są również następujące dostosowania trzmiela:

Jak skonfigurować nVidia Optimus / Bumblebee w 14.04

Brzmi jak błąd 1428972 lp .

Użytkownik fennytansy dodał obejście w komentarzu nr 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

Pomyślnie zainstalowałem CUDA przy użyciu metody runfile. Konfiguracja jest nieco trudniejsza, ponieważ główny sterownik karty graficznej należy również zainstalować przy użyciu metody pliku runfile ( patrz tutaj ).

Spróbuj zainstalować tylko sterownik. Można to zrobić za pomocą metody runfile. Będzie monitował o każdą część instalacji i możesz wyłączyć GLbiblioteki i zestawy narzędzi. Centrum kontroli jedności dawało mi również problemy z powodu konieczności użycia próbki CUDA libGLU.sozamiast libGL.so. Jest to łatwa poprawka przy tworzeniu własnych przykładów uczenia się.

Spróbuj odinstalować sterownik NVIDIA i bezpośrednio zainstalować Cuda bez niego. Na świeżym Ubuntu 14.04 postępowałem zgodnie z instrukcjami ze strony nvidia . Oprócz weryfikacji kompatybilnych wersji rzeczy (gcc, jądro), instrukcje były następujące:

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

Na szczęście poprawny sterownik nvidia został zainstalowany jako produkt uboczny powyższych kroków.

Spędziłem cały dzień starając się użyć „ ppa: graphics-drivers / ppa ” do aktualizacji sterowników NVIDIA do wersji 352. Wszystko się nie udało. Po jednej instalacji gpu-manager.log zgłosił, że sterowniki zostały zainstalowane, podczas gdy Xorg.0.log zgłosi coś przeciwnego.

Sterownik nouveau został usunięty i umieszczony na czarnej liście: sudo apt-get --purge remove xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf czarna lista opcje nouveau nouveau modeset = 0 alias nouveau off alias lbm-nouveau off

W końcu poddałem się i zastosowałem rozwiązanie „NVIDIA ... bin”.

1. Nouveau na czarnej liście, jak pokazano powyżej.
2. całkowicie odinstalował nouveau Xserver, jak cytowano powyżej.
3. Ustaw bios systemu tak, aby PCIe (dwie karty NVIDIA) były podstawowe, i dezaktywuj interfejs HD4600 na płycie głównej.
4. uruchomił się w trybie odzyskiwania, aktywował sieć, a następnie przeszedł do trybu konsoli.
5. Uruchom „NVIDIA-Linux-x86_64-352.41.run -uninstall”, aby upewnić się, że nic nie zostało.
6. Usunięto wszystkie stare katalogi w / etc, / usr / local, które wyglądały jak pozostałość po poprzednich instalacjach cuda lub nvidia.
7. Ran „NVIDIA-Linux-x86_64-352.41.run”
8. Uruchom „NVIDIA-Linux-x86_64-352.41.run --check”, aby sprawdzić, czy wszystko jest w porządku (tak było).
9. Następnie uruchomiłem „cuda_7.5.18_linux.run”, aby zakończyć instalację. Rzeczy obecnie działają. Oba monitory działają i działają. Obecnie pracuję nad budowaniem przykładowych plików cuda. Pamiętaj, aby użyć flag „--help” na pojemnikach instalacyjnych NVIDIA. Głównym powodem, dla którego zdecydowałem się przejść na trasę bin (wraz z jedną z niedziałających alternatyw, jest to, że podejście „bin” zapewnia łatwą drogę do odzyskania po aktualizacji OpenGL „mesa”.

Ponownie uruchomiłem dzisiaj Ubuntu i stwierdziłem, że istnieje inna niespełniona zależność, taka jak libcog15 : Depends: mesa-driver...(nie pamiętam pełnej nazwy pakietu), więc apt-get installinstalowałem „sterownik mesa”. Następnie CUDA 7.5 został pomyślnie zainstalowany.

Zauważ, że moja wersja jądra to 3.19.0-28-generic, a wersja gcc to Ubuntu 4.8.4-2ubuntu1 ~ 14.04 , czego nie ma w oficjalnych dokumentach CUDA 7.5 . Sprawdzę, czy to naprawdę działa.

Próbowałem sudo su i apt-get install cuda zamiast sudo apt-get install cuda. Zadziałało.

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

Proszę odnieść się do: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md . Zasadniczo jest on związany z instalacją Caffe, ale dotyczy również instalacji CUDA.

-problemy z logowaniem lightdm (pętla logowania)

-problemy ze sterownikiem istall („Instalacja sterownika nie powiodła się: wygląda na to, że serwer X działa…”)

Aby pomyślnie zainstalować NVidia CUDA Toolkit na Ubuntu 16.04 64bit, po prostu musiałem zrobić:

1. zrób obraz Ubuntu na pendrive (wystarczy 8 GB pióra) - taka próba pozwoli zaoszczędzić mnóstwo nerwów , zanim nie uda się instalacja na twoim systemie Linux !!!
2. zaloguj się podczas sesji na żywo na pendrive („Wypróbuj Ubuntu, przed instalacją”)

3. dodaj użytkownika sudo podczas sesji na żywo:

   sudo adduser admin (#pass: admin1)

   sudo usermod -aG sudo admin

4. wyloguj się z sesji na żywo, zaloguj się jako #admin

5. pobierz CUDA Toolkit z oficjalnej strony NVidia (~ 1,5 GB)

6. zmień uprawnienia do pobranego pliku instalatora (NIE INSTALUJ W TYM KROKU!):
   sudo chmod + x cuda_X.X.run

7. przejdź do widoku konsoli:

   Ctr + Alt + F1 (aby włączyć widok terminala) Ctr + Alt + F7 (aby przełączyć z widoku terminala na serwer graficzny)

8. w widoku konsoli (Ctr + Alt + F1) zaloguj się:

   login: admin pass: admin1

9. zatrzymaj usługę uruchamiania graficznego:

   sudo service lightdm stop

10. sprawdź, czy serwer graficzny jest wyłączony - po przełączeniu Ctr + Alt + F7 monitor powinien być pusty czarny, przełącz z powrotem na widok konsoli Ctr + Alt + F1

11. zainstaluj CUDA Toolkit, z taką konfiguracją:

    sudo ./cuda_X.X.run (naciśnij „q”, aby pominąć odczyt licencji) nie instaluj biblioteki OpenGL nie aktualizuj konfiguracji systemu X inne opcje ustawiają tak i ścieżki jako domyślne

12. włącz serwer graficzny:

    usługa sudo lightdm start

13. zaloguj się jako użytkownik (jeśli automatycznie logujesz się jako #ubuntu podczas sesji wylogowania na żywo):

    login: admin pass: admin1

14. sprawdź, co kompilator nvcc działa z podaną prostą sumą wektorów równoległych w blokach GPU:

    zapisz vecSum.cu i book.h w nowych plikach, skompiluj i uruchom na terminalu: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear && ./a.out

15. sprawdź wydruk konsoli - powinien być podobny do: 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. jeśli wszystko poszło dobrze podczas sesji na żywo pendrive, zrób to samo na swoim systemie Linux

PS Pamiętaj, że nie jest to idealny samouczek, ale działa dobrze dla mnie!

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