Установка CUDA немного сложна. Я выполнил следующие шаги, и это работает для меня. Вы также можете ссылаться на эту ссылку.

Подтверждение среды:

Установка CUDA -

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

sudo modprobe nvidia

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

cat /proc/driver/nvidia/version`

nvcc –V

sudo service lightdm start

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

Есть два способа установить подходящий CUDA-драйвер (для Optimus и других встроенных графических чипсетов на гибридных материнских платах) - первое, что описано здесь, является самым простым, а второе описание более громоздким, но эффективным тоже: [!d0 ]

A)

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

B)

Описание метода B здесь, но уже старше (объясняется пользователем dschinn1001) - этот метод B более унизителен и может быть рискованным, но не вредным. :

Как установить драйвер Nvidia GT 520 и Cuda 5.0 в Ubuntu13.04?

Бета-драйвер-пакет для Nvidia для загрузки для Linux находится здесь:

Как установить драйвер Nvidia GT 520 и Cuda 5.0 в Ubuntu13.04?

Метод A более прост, но не ясен, как он взаимодействует с xscreensaver и методом B старше, но пакет драйверов также обновляется в последнее время, и после того, как метод B завершен, он должен работать лучше, если xscreensaver обеспечивает установку xscreensaver. (Я тестировал метод B на 13.10, и это работало очень хорошо, даже с xscreensaver. И я думаю, что остальная часть этого потока зависит от аппаратного обеспечения.)

Кроме того, и в отношении шмеля с Optimus- графические чипсеты, эти настройки для шмеля также необходимы:

Как настроить nVidia Optimus / Bumblebee в 14.04

Звучит как ошибка lp 1428972.

Пользователь fennytansy добавил обходное решение в lp bug 1428972 :

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

Я успешно установил CUDA с помощью метода runfile. Это немного сложнее, потому что ваш основной графический драйвер также должен быть установлен с использованием метода runfile (см. Здесь).

Попробуйте установить также драйвер. Это можно сделать с помощью метода runfile. Он предложит вам каждую часть установки, и вы можете отключить библиотеки GL и инструментальные средства. Центр управления единством также дал мне проблемы, из-за необходимости использования CUDA для использования libGLU.so вместо libGL.so. Это простое решение при создании собственных примеров обучения.

Попробуйте удалить драйвер nvidia и напрямую установить cuda без него. На новом Ubuntu 14.04 я выполнил инструкции с сайта nvidia. Помимо проверки совместимых версий вещей (gcc, kernel), инструкции были следующими:

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

К счастью, правильный драйвер nvidia был установлен как побочный продукт описанных выше шагов.

Я провел целый день, пытаясь использовать «ppa: graphics-drivers / ppa» для обновления драйверов NVIDIA до версии 352. Все провалилось. После одной установки gpu-manager.log сообщила, что драйверы были установлены, а Xorg.0.log сообщал об обратном.

Драйвер nouveau был удален и занесен в черный список: sudo apt-get --purge удалить xserver-xorg-video-nouveau cat /etc/modprobe.d/nouveau-nomodeset-jsrobin.conf blacklist nouveau options nouveau modeset = 0 alias nouveau off alias lbm-nouveau off

Я, наконец, сдался и использовал чисто «решение NVIDIA ... bin».

Пожалуйста, обратитесь к: https://github.com/astorfi/Caffe_Deep_Learning/blob/master/Installation/readme.md. Это связано с установкой Caffe по существу, но он также обращается к установке CUDA.

Я попробовал sudo su и apt-get install cuda вместо sudo apt-get install cuda. Это сработало.

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

-problems with lightdm log in (login loop)

-проблемы с драйвером istall («Ошибка установки драйвера: похоже, что X-сервер запущен ...»)

Чтобы успешно установить NVidia CUDA Toolkit на Ubuntu 16.04 64bit, мне просто нужно было сделать:

-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

P.S. Обратите внимание, что это не идеальный учебник, но отлично работает для меня!

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