Hello BitCucos! Here is a performance test of Nvidia cards: Quadro vs GeForce vs Tesla. All are high performance cards that use GPUs to do their basic operations, increasing the capacity to do operations up to 1000 times compared to traditional CPU cards.
A hybrid parallelism protocol makes better use of the infrastructure and resources available for solving parallelizable problems. This protocol uses shared memory (OpenMP), distributed memory (MPI) and GPUs (CUDA) in order to solve this type of task in less time.
In order to improve the performance in the communication between the cores and the GPU card, a core has been provided, which is the one that has immediate access to the PCI-express bus and therefore performs the upload and download operations in a lower time than the rest of the kernels.
To know what is the fastest core, we make profiling tests to register the time of upload and download of data using this core. This method optimizes the performance of the problem, especially when dealing with problems of great complexity, more than a polynomial order.
How to identify the fastest core?
In order to identify the fastest card core, we calculated the elapsed time by marks on CUDA events, the explicit documentation of which is found at http://devblogs.nvidia.com/parallelforall/how-implement-performance-metrics-cuda- DC/
This process requires syncronization between the device and the host, both stay in the GPU pipeline. They can create, record, destroy events, etc. by this way we will calculate the elapsed time in milliseconds between two events.
In particular, to show the upload time, we record an event before scatter data into memory from the host to the device and after the event, we record another event, the time of all process is the elapsed time between these two events. In a similar way we make a copy of their data in memory from the device to the host.
With these data we will calculate the performance of each core by broadcasting the data to the Nvidia card and thus determine which core has the best profiling to perform parallel operations.
Algorithm development
To know what is the best profiling time of all cards (Nvidia Quadro vs GeForce vs Tesla), we created a function to run in the kernel of each card, this process uses the CUDA programming language to perform operations.
CUDA is a GPU-oriented programming language and enables high-performance parallel operations on Nvidia cards. To show a performance test of Quadro vs GeForce vs Tesla cards we use this language to make a simple program. This is a language that uses meta-functions, as well as specific events to be executed for each core.
In particular, this function was performed that makes the product of a scalar through the matrix uploaded to the card:
float tsub, tbaj;
float ascencore[3], bajadacore[3];
__global__ void kernelscalarVectors(double *a, int n) {
int i = threadIdx.x + blockIdx.x * blockDim.x;
scalar int = 10;
while(i<n) {
a[i]=a[i]*scalar;
i+=blockDim.x*gridDim.x;
}}
Then we created a function to be invoked by the kernel to run an independent process on each card and know their best performance of all Nvida cards: Quadro vs GeForce vs Tesla respectively, using the CUDA language. This function is invoked by a MPI process that begins through the main function (seen later).
For them, 4 events were created (begin upload, end upload, begin download, end download) to take the uploaded and downloaded data and calculate the elapsed time in that order to perform an analysis of the performance of each card. Before and after these events (upload and download of data to the card), we record an event to register those times on each of the cards:
void scalarVectoresInDevice (double a[], int n, int device) {
double *aD;
int size = N * sizeof(double);
cudaEvent_t startup, stopup, startdown, stopdown; cudaSetDevice(device);
cudaEventCreate(&startup);
cudaEventCreate(&highup);
cudaEventCreate(&startdownload);
cudaEventCreate(&highdown);
cudaMalloc(&aD, size);
cudaEventRecord(startup, 0);
cudaEventSynchronize(startup);
cudaMemcpy(aD, a, size, cudaMemcpyHostToDevice);
cudaEventRecord(highup, 0);
cudaEventSynchronize(highup);
kernelscalarVectores<<<4096,4096>>>(aD, n);
cudaEventRecord(startdown, 0);
cudaEventSynchronize(startdown);
cudaMemcpy(a, aD, size, cudaMemcpyDeviceToHost);
cudaEventRecord(highdown, 0);
cudaEventSynchronize(highdown);
cudaEventElapsedTime(&tsub, startup, stopup);
cudaEventElapsedTime(&tbaj, startdown, highdown);
cudaEventDestroy(startup);
cudaEventDestroy(highup);
cudaEventDestroy(startdown);
cudaEventDestroy(highdown);
cudaFree(aD);
}
Within the main function we take the characteristics of each CUDA card as well as the invocation of the profiling measuring function. The advantage of using MPI is that the kernel allocation for each core is divided by the same mpi. We send these functions to them and calculated the elapsed time of their arrays by the same way.
Nvidia Quadro vs Geforce, or Nvidia Tesla?
To choice what card has a better communication between the cores and sockets of the cards, we have the follow results of elapsed time of each card:
Best cores per card
Nvidia Tesla C2070 card Best core: 4 Time = 0.202096
Nvidia GeForce GTX 460 card Best core: 11 Time = 0.197680
Nvidia Quadro K2000 card Best core: 10 Time = 0.195536
Uses of Nvidia Quadro, GeForce and Tesla cards
Any parallel application that has an independent process of synchronization process, it is possible to implemt their code through GPU, some examples of applications that can be done through parallel computation and are the following:
Virtual Reality Applications: Many of the used processes to render an engine can be done by parallel computing, improving the graphics and acquiring superior performance.
Machine Learning Applications: Machine learning based on human knowledge, simulates human learning routines, suitable for development uses parallel computing.
Also Read: Internet Money