-Các biểu tượng với đăng nhập lightdm (vòng đăng nhập)
-Các biểu tượng với trình điều khiển istall ("Cài đặt trình điều khiển không thành công: có vẻ như máy chủ X đang chạy ...")
Để cài đặt thành công Bộ công cụ NVDA CUDA trên Ubuntu 16.04 64 bit tôi chỉ phải làm:
- tạo một hình ảnh trực tiếp của Ubuntu trên Pendrive (bút 8GB là đủ) - một lần thử như vậy sẽ tiết kiệm được rất nhiều dây thần kinh , trước khi cài đặt không thành công trên hệ thống Linux máy chủ của bạn !!!
- đăng nhập vào phiên trực tiếp trên Pendrive ("Hãy thử Ubuntu, trước khi cài đặt")
thêm người dùng sudo tại phiên trực tiếp:
quản trị viên sudo adduser (#pass: admin1)
sudo usermod -aG sudo quản trị
đăng xuất từ phiên trực tiếp, đăng nhập với tên #admin
- tải xuống Bộ công cụ CUDA từ trang web chính thức của NVidia (~ 1,5 GB)
thay đổi đặc quyền cho tệp trình cài đặt đã tải xuống (KHÔNG CÀI ĐẶT TẠI BƯỚC NÀY!):
sudo chmod + x cuda_X.X.run
chuyển sang giao diện điều khiển:
Ctr + Alt + F1 (để bật chế độ xem thiết bị đầu cuối) Ctr + Alt + F7 (để chuyển từ chế độ xem thiết bị đầu cuối sang máy chủ đồ họa)
tại giao diện điều khiển (Ctr + Alt + F1) đăng nhập:
đăng nhập: quản trị viên vượt qua: admin1
dừng dịch vụ chạy đồ họa:
dịch vụ sudo dừng lightdm
kiểm tra xem máy chủ đồ họa có tắt không - sau khi chuyển đổi Ctr + Alt + F7, màn hình sẽ có màu đen trống, chuyển trở lại trên giao diện điều khiển Ctr + Alt + F1
cài đặt CUDA Toolkit, với cấu hình như vậy:
sudo ./cuda_X.X.run (nhấn 'q' để bỏ qua đọc giấy phép) không cài đặt thư viện OpenGL không cập nhật cấu hình hệ thống X, các tùy chọn khác làm cho có và đường dẫn làm mặc định
bật máy chủ đồ họa:
dịch vụ sudo bắt đầu
đăng nhập với tư cách người dùng (nếu bạn tự động đăng nhập với tư cách #ubfox khi đăng xuất phiên trực tiếp):
đăng nhập: quản trị viên vượt qua: admin1
kiểm tra mọi trình biên dịch nvcc hoạt động với tổng vectơ song song đơn giản được cung cấp tại Khối GPU:
lưu vecSum.cu và book.h vào các tệp mới, biên dịch và chạy tại terminal: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && xóa && ./a.out
kiểm tra bản in giao diện điều khiển - nó sẽ tương tự như: 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
Nếu mọi thứ diễn ra tốt đẹp trên phiên trực tiếp, hãy làm tương tự trên hệ thống máy chủ linux của bạn
PS Xin lưu ý rằng nó không phải là hướng dẫn lý tưởng, nhưng hoạt động tốt với tôi!
======= 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;
}
========= cuốn sách.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). Các trình điều khiển khác sinh ra tôi vào các vòng đăng nhập hoặc màu đenunity-greeter! Tôi không thể cảm ơn đủ :))