-वास्तविकता के साथ lightdm लॉग इन (लॉगिन लूप)
ड्राइवर आइसटॉल ("चालक स्थापना विफल: यह प्रतीत होता है, कि एक एक्स सर्वर चल रहा है ..." के साथ -problems)
उबंटू 16.04 64bit पर एक NVidia CUDA टूलकिट को सफलतापूर्वक स्थापित करने के लिए मुझे अभी करना है:
- पेनड्राइव पर उबंटू का लाइवमेज बनाएं (8 जीबी पेन पर्याप्त है) - इस तरह की कोशिश आपके मेजबान लिनक्स सिस्टम पर असफल इंस्टालेशन से पहले, एक टन नसों को बचाएगी !!!
- pendrive पर लाइव सत्र में प्रवेश करें ("स्थापित करने से पहले Ubuntu की कोशिश करें")
लाइव सत्र में sudo उपयोगकर्ता जोड़ें:
sudo adduser admin (#pass: admin1)
sudo usermod -aG सुडो एडमिन
लाइव सत्र से लॉगआउट करें, #admin के रूप में लॉग इन करें
- NVIDia आधिकारिक साइट से CUDA टूलकिट डाउनलोड करें (~ 1.5GB)
डाउनलोड की गई इंस्टॉलर फ़ाइल के लिए विशेषाधिकारों को बदलें (इस चरण में
सम्मिलित न हों !): sudo chmod + x cuda_X.X.run
कंसोल दृश्य पर स्विच करें:
Ctr + Alt + F1 (टर्मिनल दृश्य पर स्विच करने के लिए) Ctr + Alt + F7 (टर्मिनल दृश्य से ग्राफ़िकल सर्वर पर स्विच करने के लिए)
कंसोल पर देखें (Ctr + Alt + F1) लॉग इन करें:
लॉगिन: व्यवस्थापक पास: admin1
चित्रमय चल सेवा बंद करें:
sudo सेवा lightdm बंद करो
जाँच करें कि क्या ग्राफिकल सर्वर बंद है - सीटीआर + Alt + F7 स्विच करने के बाद मॉनिटर खाली काला होना चाहिए, कंसोल दृश्य पर वापस स्विच करें सीटीआर + Alt + F1
ऐसे कॉन्फ़िगरेशन के साथ CUDA टूलकिट स्थापित करें:
sudo ./cuda_X.X.run (लाइसेंस रीड स्किप के लिए 'q' दबाएं) OpenGL लाइब्रेरी स्थापित न करें सिस्टम को अपडेट न करें एक्स कॉन्फ़िगरेशन अन्य विकल्प हां और पथ को डिफ़ॉल्ट रूप में बनाते हैं
चित्रमय सर्वर चालू करें:
sudo सेवा lightdm प्रारंभ
उपयोगकर्ता के रूप में लॉग इन करें (यदि आप लाइव सत्र लॉग आउट में स्वचालित रूप से #ubuntu के रूप में लॉग इन करते हैं):
लॉगिन: व्यवस्थापक पास: admin1
GPU ब्लॉक पर सरल समानांतर वेक्टर राशि के साथ जो भी nvcc संकलक काम करता है उसकी जाँच करें:
नई फ़ाइलों पर vecSum.cu और book.h को सहेजें, संकलन करें और टर्मिनल पर चलाएँ: /usr/local/cuda-8.0/bin/nvcc vecSum.cu && clear &&/a.out
कंसोल कंसोल चेक करें - यह समान होना चाहिए: 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
अगर सबकुछ pendrive live session पर अच्छा गया, तो अपने host linux system पर भी ऐसा ही करें
पीएस कृपया ध्यान दें कि यह आदर्श ट्यूटोरियल नहीं है, लेकिन मेरे लिए ठीक काम करता है!
======= 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;
}
========= पुस्तक।ह ======
/*
* 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)। अन्य ड्राइवरों ने मुझे लॉगिन लूप या ब्लैक में देखाunity-greeter! मैं आपको पर्याप्त धन्यवाद नहीं दे सकता