-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:
- 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 !!!
- connectez-vous en session en direct sur pendrive ("Essayez Ubuntu, avant l'installation")
ajouter un utilisateur sudo lors d'une session en direct:
sudo adduser admin (#pass: admin1)
sudo usermod -aG sudo admin
déconnectez-vous de la session en direct, connectez-vous en tant que #admin
- télécharger CUDA Toolkit depuis le site officiel de NVidia (~ 1,5 Go)
changer les privilèges pour le fichier d'installation téléchargé (NE PAS INSTALLER À CETTE ÉTAPE!):
sudo chmod + x cuda_X.X.run
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)
dans la vue console (Ctr + Alt + F1), connectez-vous:
connexion: admin passe: admin1
arrêter le service d'exécution graphique:
sudo service lightdm stop
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
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
activer le serveur graphique:
sudo service lightdm start
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
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
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
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__
optirun). D'autres pilotes m'ont donné naissance à des boucles de connexion ou en noirunity-greeter! Je ne vous remercierai jamais assez