mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-26 06:38:16 +08:00
Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.
This commit is contained in:
Rob Armstrong
@@ -65,15 +65,15 @@
|
||||
|
||||
// Utilities and system includes
|
||||
#include <assert.h>
|
||||
#include <helper_string.h> // helper for shared functions common to CUDA Samples
|
||||
#include <helper_string.h> // helper for shared functions common to CUDA Samples
|
||||
|
||||
// CUDA runtime
|
||||
#include <cuda_runtime.h>
|
||||
#include <cublas_v2.h>
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
// CUDA and CUBLAS functions
|
||||
#include <helper_functions.h>
|
||||
#include <helper_cuda.h>
|
||||
#include <helper_functions.h>
|
||||
|
||||
#ifndef min
|
||||
#define min(a, b) ((a < b) ? a : b)
|
||||
@@ -83,8 +83,9 @@
|
||||
#endif
|
||||
|
||||
// Optional Command-line multiplier for matrix sizes
|
||||
typedef struct _matrixSize {
|
||||
unsigned int uiWA, uiHA, uiWB, uiHB, uiWC, uiHC;
|
||||
typedef struct _matrixSize
|
||||
{
|
||||
unsigned int uiWA, uiHA, uiWB, uiHB, uiWC, uiHC;
|
||||
} sMatrixSize;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -96,270 +97,292 @@ typedef struct _matrixSize {
|
||||
//! @param hA height of matrix A
|
||||
//! @param wB width of matrix B
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void matrixMulCPU(float *C, const float *A, const float *B, unsigned int hA,
|
||||
unsigned int wA, unsigned int wB) {
|
||||
for (unsigned int i = 0; i < hA; ++i)
|
||||
for (unsigned int j = 0; j < wB; ++j) {
|
||||
double sum = 0;
|
||||
void matrixMulCPU(float *C, const float *A, const float *B, unsigned int hA, unsigned int wA, unsigned int wB)
|
||||
{
|
||||
for (unsigned int i = 0; i < hA; ++i)
|
||||
for (unsigned int j = 0; j < wB; ++j) {
|
||||
double sum = 0;
|
||||
|
||||
for (unsigned int k = 0; k < wA; ++k) {
|
||||
double a = A[i * wA + k];
|
||||
double b = B[k * wB + j];
|
||||
sum += a * b;
|
||||
}
|
||||
for (unsigned int k = 0; k < wA; ++k) {
|
||||
double a = A[i * wA + k];
|
||||
double b = B[k * wB + j];
|
||||
sum += a * b;
|
||||
}
|
||||
|
||||
C[i * wB + j] = (float)sum;
|
||||
}
|
||||
C[i * wB + j] = (float)sum;
|
||||
}
|
||||
}
|
||||
|
||||
// Allocates a matrix with random float entries.
|
||||
void randomInit(float *data, int size) {
|
||||
for (int i = 0; i < size; ++i) data[i] = rand() / (float)RAND_MAX;
|
||||
void randomInit(float *data, int size)
|
||||
{
|
||||
for (int i = 0; i < size; ++i)
|
||||
data[i] = rand() / (float)RAND_MAX;
|
||||
}
|
||||
|
||||
void printDiff(float *data1, float *data2, int width, int height,
|
||||
int iListLength, float fListTol) {
|
||||
printf("Listing first %d Differences > %.6f...\n", iListLength, fListTol);
|
||||
int i, j, k;
|
||||
int error_count = 0;
|
||||
void printDiff(float *data1, float *data2, int width, int height, int iListLength, float fListTol)
|
||||
{
|
||||
printf("Listing first %d Differences > %.6f...\n", iListLength, fListTol);
|
||||
int i, j, k;
|
||||
int error_count = 0;
|
||||
|
||||
for (j = 0; j < height; j++) {
|
||||
if (error_count < iListLength) {
|
||||
printf("\n Row %d:\n", j);
|
||||
}
|
||||
|
||||
for (i = 0; i < width; i++) {
|
||||
k = j * width + i;
|
||||
float fDiff = fabs(data1[k] - data2[k]);
|
||||
|
||||
if (fDiff > fListTol) {
|
||||
for (j = 0; j < height; j++) {
|
||||
if (error_count < iListLength) {
|
||||
printf(" Loc(%d,%d)\tCPU=%.5f\tGPU=%.5f\tDiff=%.6f\n", i, j,
|
||||
data1[k], data2[k], fDiff);
|
||||
printf("\n Row %d:\n", j);
|
||||
}
|
||||
|
||||
error_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i = 0; i < width; i++) {
|
||||
k = j * width + i;
|
||||
float fDiff = fabs(data1[k] - data2[k]);
|
||||
|
||||
printf(" \n Total Errors = %d\n", error_count);
|
||||
if (fDiff > fListTol) {
|
||||
if (error_count < iListLength) {
|
||||
printf(" Loc(%d,%d)\tCPU=%.5f\tGPU=%.5f\tDiff=%.6f\n", i, j, data1[k], data2[k], fDiff);
|
||||
}
|
||||
|
||||
error_count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printf(" \n Total Errors = %d\n", error_count);
|
||||
}
|
||||
|
||||
void initializeCUDA(int argc, char **argv, int &devID, int &iSizeMultiple,
|
||||
sMatrixSize &matrix_size) {
|
||||
// By default, we use device 0, otherwise we override the device ID based on
|
||||
// what is provided at the command line
|
||||
cudaError_t error;
|
||||
devID = 0;
|
||||
void initializeCUDA(int argc, char **argv, int &devID, int &iSizeMultiple, sMatrixSize &matrix_size)
|
||||
{
|
||||
// By default, we use device 0, otherwise we override the device ID based on
|
||||
// what is provided at the command line
|
||||
cudaError_t error;
|
||||
devID = 0;
|
||||
|
||||
devID = findCudaDevice(argc, (const char **)argv);
|
||||
devID = findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "sizemult")) {
|
||||
iSizeMultiple =
|
||||
getCmdLineArgumentInt(argc, (const char **)argv, "sizemult");
|
||||
}
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "sizemult")) {
|
||||
iSizeMultiple = getCmdLineArgumentInt(argc, (const char **)argv, "sizemult");
|
||||
}
|
||||
|
||||
iSizeMultiple = min(iSizeMultiple, 10);
|
||||
iSizeMultiple = max(iSizeMultiple, 1);
|
||||
iSizeMultiple = min(iSizeMultiple, 10);
|
||||
iSizeMultiple = max(iSizeMultiple, 1);
|
||||
|
||||
cudaDeviceProp deviceProp;
|
||||
cudaDeviceProp deviceProp;
|
||||
|
||||
error = cudaGetDeviceProperties(&deviceProp, devID);
|
||||
error = cudaGetDeviceProperties(&deviceProp, devID);
|
||||
|
||||
if (error != cudaSuccess) {
|
||||
printf("cudaGetDeviceProperties returned error code %d, line(%d)\n", error,
|
||||
__LINE__);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (error != cudaSuccess) {
|
||||
printf("cudaGetDeviceProperties returned error code %d, line(%d)\n", error, __LINE__);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n", devID,
|
||||
deviceProp.name, deviceProp.major, deviceProp.minor);
|
||||
printf("GPU Device %d: \"%s\" with compute capability %d.%d\n\n",
|
||||
devID,
|
||||
deviceProp.name,
|
||||
deviceProp.major,
|
||||
deviceProp.minor);
|
||||
|
||||
int block_size = 32;
|
||||
int block_size = 32;
|
||||
|
||||
matrix_size.uiWA = 3 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHA = 4 * block_size * iSizeMultiple;
|
||||
matrix_size.uiWB = 2 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHB = 3 * block_size * iSizeMultiple;
|
||||
matrix_size.uiWC = 2 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHC = 4 * block_size * iSizeMultiple;
|
||||
matrix_size.uiWA = 3 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHA = 4 * block_size * iSizeMultiple;
|
||||
matrix_size.uiWB = 2 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHB = 3 * block_size * iSizeMultiple;
|
||||
matrix_size.uiWC = 2 * block_size * iSizeMultiple;
|
||||
matrix_size.uiHC = 4 * block_size * iSizeMultiple;
|
||||
|
||||
printf("MatrixA(%u,%u), MatrixB(%u,%u), MatrixC(%u,%u)\n", matrix_size.uiHA,
|
||||
matrix_size.uiWA, matrix_size.uiHB, matrix_size.uiWB, matrix_size.uiHC,
|
||||
matrix_size.uiWC);
|
||||
printf("MatrixA(%u,%u), MatrixB(%u,%u), MatrixC(%u,%u)\n",
|
||||
matrix_size.uiHA,
|
||||
matrix_size.uiWA,
|
||||
matrix_size.uiHB,
|
||||
matrix_size.uiWB,
|
||||
matrix_size.uiHC,
|
||||
matrix_size.uiWC);
|
||||
|
||||
if (matrix_size.uiWA != matrix_size.uiHB ||
|
||||
matrix_size.uiHA != matrix_size.uiHC ||
|
||||
matrix_size.uiWB != matrix_size.uiWC) {
|
||||
printf("ERROR: Matrix sizes do not match!\n");
|
||||
exit(-1);
|
||||
}
|
||||
if (matrix_size.uiWA != matrix_size.uiHB || matrix_size.uiHA != matrix_size.uiHC
|
||||
|| matrix_size.uiWB != matrix_size.uiWC) {
|
||||
printf("ERROR: Matrix sizes do not match!\n");
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Run a simple test matrix multiply using CUBLAS
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
int matrixMultiply(int argc, char **argv, int devID, sMatrixSize &matrix_size) {
|
||||
cudaDeviceProp deviceProp;
|
||||
int matrixMultiply(int argc, char **argv, int devID, sMatrixSize &matrix_size)
|
||||
{
|
||||
cudaDeviceProp deviceProp;
|
||||
|
||||
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
|
||||
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, devID));
|
||||
|
||||
int block_size = 32;
|
||||
int block_size = 32;
|
||||
|
||||
// set seed for rand()
|
||||
srand(2006);
|
||||
// set seed for rand()
|
||||
srand(2006);
|
||||
|
||||
// allocate host memory for matrices A and B
|
||||
unsigned int size_A = matrix_size.uiWA * matrix_size.uiHA;
|
||||
unsigned int mem_size_A = sizeof(float) * size_A;
|
||||
float *h_A = (float *)malloc(mem_size_A);
|
||||
unsigned int size_B = matrix_size.uiWB * matrix_size.uiHB;
|
||||
unsigned int mem_size_B = sizeof(float) * size_B;
|
||||
float *h_B = (float *)malloc(mem_size_B);
|
||||
// allocate host memory for matrices A and B
|
||||
unsigned int size_A = matrix_size.uiWA * matrix_size.uiHA;
|
||||
unsigned int mem_size_A = sizeof(float) * size_A;
|
||||
float *h_A = (float *)malloc(mem_size_A);
|
||||
unsigned int size_B = matrix_size.uiWB * matrix_size.uiHB;
|
||||
unsigned int mem_size_B = sizeof(float) * size_B;
|
||||
float *h_B = (float *)malloc(mem_size_B);
|
||||
|
||||
// set seed for rand()
|
||||
srand(2006);
|
||||
// set seed for rand()
|
||||
srand(2006);
|
||||
|
||||
// initialize host memory
|
||||
randomInit(h_A, size_A);
|
||||
randomInit(h_B, size_B);
|
||||
// initialize host memory
|
||||
randomInit(h_A, size_A);
|
||||
randomInit(h_B, size_B);
|
||||
|
||||
// allocate device memory
|
||||
float *d_A, *d_B, *d_C;
|
||||
unsigned int size_C = matrix_size.uiWC * matrix_size.uiHC;
|
||||
unsigned int mem_size_C = sizeof(float) * size_C;
|
||||
// allocate device memory
|
||||
float *d_A, *d_B, *d_C;
|
||||
unsigned int size_C = matrix_size.uiWC * matrix_size.uiHC;
|
||||
unsigned int mem_size_C = sizeof(float) * size_C;
|
||||
|
||||
// allocate host memory for the result
|
||||
float *h_C = (float *)malloc(mem_size_C);
|
||||
float *h_CUBLAS = (float *)malloc(mem_size_C);
|
||||
// allocate host memory for the result
|
||||
float *h_C = (float *)malloc(mem_size_C);
|
||||
float *h_CUBLAS = (float *)malloc(mem_size_C);
|
||||
|
||||
checkCudaErrors(cudaMalloc((void **)&d_A, mem_size_A));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_B, mem_size_B));
|
||||
checkCudaErrors(cudaMemcpy(d_A, h_A, mem_size_A, cudaMemcpyHostToDevice));
|
||||
checkCudaErrors(cudaMemcpy(d_B, h_B, mem_size_B, cudaMemcpyHostToDevice));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_C, mem_size_C));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_A, mem_size_A));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_B, mem_size_B));
|
||||
checkCudaErrors(cudaMemcpy(d_A, h_A, mem_size_A, cudaMemcpyHostToDevice));
|
||||
checkCudaErrors(cudaMemcpy(d_B, h_B, mem_size_B, cudaMemcpyHostToDevice));
|
||||
checkCudaErrors(cudaMalloc((void **)&d_C, mem_size_C));
|
||||
|
||||
// setup execution parameters
|
||||
dim3 threads(block_size, block_size);
|
||||
dim3 grid(matrix_size.uiWC / threads.x, matrix_size.uiHC / threads.y);
|
||||
// setup execution parameters
|
||||
dim3 threads(block_size, block_size);
|
||||
dim3 grid(matrix_size.uiWC / threads.x, matrix_size.uiHC / threads.y);
|
||||
|
||||
// create and start timer
|
||||
printf("Computing result using CUBLAS...");
|
||||
// create and start timer
|
||||
printf("Computing result using CUBLAS...");
|
||||
|
||||
// execute the kernel
|
||||
int nIter = 30;
|
||||
// execute the kernel
|
||||
int nIter = 30;
|
||||
|
||||
// CUBLAS version 2.0
|
||||
{
|
||||
const float alpha = 1.0f;
|
||||
const float beta = 0.0f;
|
||||
cublasHandle_t handle;
|
||||
cudaEvent_t start, stop;
|
||||
// CUBLAS version 2.0
|
||||
{
|
||||
const float alpha = 1.0f;
|
||||
const float beta = 0.0f;
|
||||
cublasHandle_t handle;
|
||||
cudaEvent_t start, stop;
|
||||
|
||||
checkCudaErrors(cublasCreate(&handle));
|
||||
checkCudaErrors(cublasCreate(&handle));
|
||||
|
||||
// Perform warmup operation with cublas
|
||||
checkCudaErrors(cublasSgemm(
|
||||
handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiWB, matrix_size.uiHA,
|
||||
matrix_size.uiWA, &alpha, d_B, matrix_size.uiWB, d_A, matrix_size.uiWA,
|
||||
&beta, d_C, matrix_size.uiWB));
|
||||
// Perform warmup operation with cublas
|
||||
checkCudaErrors(cublasSgemm(handle,
|
||||
CUBLAS_OP_N,
|
||||
CUBLAS_OP_N,
|
||||
matrix_size.uiWB,
|
||||
matrix_size.uiHA,
|
||||
matrix_size.uiWA,
|
||||
&alpha,
|
||||
d_B,
|
||||
matrix_size.uiWB,
|
||||
d_A,
|
||||
matrix_size.uiWA,
|
||||
&beta,
|
||||
d_C,
|
||||
matrix_size.uiWB));
|
||||
|
||||
// Allocate CUDA events that we'll use for timing
|
||||
checkCudaErrors(cudaEventCreate(&start));
|
||||
checkCudaErrors(cudaEventCreate(&stop));
|
||||
// Allocate CUDA events that we'll use for timing
|
||||
checkCudaErrors(cudaEventCreate(&start));
|
||||
checkCudaErrors(cudaEventCreate(&stop));
|
||||
|
||||
// Record the start event
|
||||
checkCudaErrors(cudaEventRecord(start, NULL));
|
||||
// Record the start event
|
||||
checkCudaErrors(cudaEventRecord(start, NULL));
|
||||
|
||||
for (int j = 0; j < nIter; j++) {
|
||||
// note cublas is column primary!
|
||||
// need to transpose the order
|
||||
checkCudaErrors(cublasSgemm(
|
||||
handle, CUBLAS_OP_N, CUBLAS_OP_N, matrix_size.uiWB, matrix_size.uiHA,
|
||||
matrix_size.uiWA, &alpha, d_B, matrix_size.uiWB, d_A,
|
||||
matrix_size.uiWA, &beta, d_C, matrix_size.uiWB));
|
||||
for (int j = 0; j < nIter; j++) {
|
||||
// note cublas is column primary!
|
||||
// need to transpose the order
|
||||
checkCudaErrors(cublasSgemm(handle,
|
||||
CUBLAS_OP_N,
|
||||
CUBLAS_OP_N,
|
||||
matrix_size.uiWB,
|
||||
matrix_size.uiHA,
|
||||
matrix_size.uiWA,
|
||||
&alpha,
|
||||
d_B,
|
||||
matrix_size.uiWB,
|
||||
d_A,
|
||||
matrix_size.uiWA,
|
||||
&beta,
|
||||
d_C,
|
||||
matrix_size.uiWB));
|
||||
}
|
||||
|
||||
printf("done.\n");
|
||||
|
||||
// Record the stop event
|
||||
checkCudaErrors(cudaEventRecord(stop, NULL));
|
||||
|
||||
// Wait for the stop event to complete
|
||||
checkCudaErrors(cudaEventSynchronize(stop));
|
||||
|
||||
float msecTotal = 0.0f;
|
||||
checkCudaErrors(cudaEventElapsedTime(&msecTotal, start, stop));
|
||||
|
||||
// Compute and print the performance
|
||||
float msecPerMatrixMul = msecTotal / nIter;
|
||||
double flopsPerMatrixMul = 2.0 * (double)matrix_size.uiHC * (double)matrix_size.uiWC * (double)matrix_size.uiHB;
|
||||
double gigaFlops = (flopsPerMatrixMul * 1.0e-9f) / (msecPerMatrixMul / 1000.0f);
|
||||
printf("Performance= %.2f GFlop/s, Time= %.3f msec, Size= %.0f Ops\n",
|
||||
gigaFlops,
|
||||
msecPerMatrixMul,
|
||||
flopsPerMatrixMul);
|
||||
|
||||
// copy result from device to host
|
||||
checkCudaErrors(cudaMemcpy(h_CUBLAS, d_C, mem_size_C, cudaMemcpyDeviceToHost));
|
||||
|
||||
// Destroy the handle
|
||||
checkCudaErrors(cublasDestroy(handle));
|
||||
}
|
||||
|
||||
// compute reference solution
|
||||
printf("Computing result using host CPU...");
|
||||
float *reference = (float *)malloc(mem_size_C);
|
||||
matrixMulCPU(reference, h_A, h_B, matrix_size.uiHA, matrix_size.uiWA, matrix_size.uiWB);
|
||||
printf("done.\n");
|
||||
|
||||
// Record the stop event
|
||||
checkCudaErrors(cudaEventRecord(stop, NULL));
|
||||
// check result (CUBLAS)
|
||||
bool resCUBLAS = sdkCompareL2fe(reference, h_CUBLAS, size_C, 1.0e-6f);
|
||||
|
||||
// Wait for the stop event to complete
|
||||
checkCudaErrors(cudaEventSynchronize(stop));
|
||||
if (resCUBLAS != true) {
|
||||
printDiff(reference, h_CUBLAS, matrix_size.uiWC, matrix_size.uiHC, 100, 1.0e-5f);
|
||||
}
|
||||
|
||||
float msecTotal = 0.0f;
|
||||
checkCudaErrors(cudaEventElapsedTime(&msecTotal, start, stop));
|
||||
printf("Comparing CUBLAS Matrix Multiply with CPU results: %s\n", (true == resCUBLAS) ? "PASS" : "FAIL");
|
||||
|
||||
// Compute and print the performance
|
||||
float msecPerMatrixMul = msecTotal / nIter;
|
||||
double flopsPerMatrixMul = 2.0 * (double)matrix_size.uiHC *
|
||||
(double)matrix_size.uiWC *
|
||||
(double)matrix_size.uiHB;
|
||||
double gigaFlops =
|
||||
(flopsPerMatrixMul * 1.0e-9f) / (msecPerMatrixMul / 1000.0f);
|
||||
printf("Performance= %.2f GFlop/s, Time= %.3f msec, Size= %.0f Ops\n",
|
||||
gigaFlops, msecPerMatrixMul, flopsPerMatrixMul);
|
||||
printf("\nNOTE: The CUDA Samples are not meant for performance measurements. "
|
||||
"Results may vary when GPU Boost is enabled.\n");
|
||||
|
||||
// copy result from device to host
|
||||
checkCudaErrors(
|
||||
cudaMemcpy(h_CUBLAS, d_C, mem_size_C, cudaMemcpyDeviceToHost));
|
||||
// clean up memory
|
||||
free(h_A);
|
||||
free(h_B);
|
||||
free(h_C);
|
||||
free(reference);
|
||||
checkCudaErrors(cudaFree(d_A));
|
||||
checkCudaErrors(cudaFree(d_B));
|
||||
checkCudaErrors(cudaFree(d_C));
|
||||
|
||||
// Destroy the handle
|
||||
checkCudaErrors(cublasDestroy(handle));
|
||||
}
|
||||
|
||||
// compute reference solution
|
||||
printf("Computing result using host CPU...");
|
||||
float *reference = (float *)malloc(mem_size_C);
|
||||
matrixMulCPU(reference, h_A, h_B, matrix_size.uiHA, matrix_size.uiWA,
|
||||
matrix_size.uiWB);
|
||||
printf("done.\n");
|
||||
|
||||
// check result (CUBLAS)
|
||||
bool resCUBLAS = sdkCompareL2fe(reference, h_CUBLAS, size_C, 1.0e-6f);
|
||||
|
||||
if (resCUBLAS != true) {
|
||||
printDiff(reference, h_CUBLAS, matrix_size.uiWC, matrix_size.uiHC, 100,
|
||||
1.0e-5f);
|
||||
}
|
||||
|
||||
printf("Comparing CUBLAS Matrix Multiply with CPU results: %s\n",
|
||||
(true == resCUBLAS) ? "PASS" : "FAIL");
|
||||
|
||||
printf(
|
||||
"\nNOTE: The CUDA Samples are not meant for performance measurements. "
|
||||
"Results may vary when GPU Boost is enabled.\n");
|
||||
|
||||
// clean up memory
|
||||
free(h_A);
|
||||
free(h_B);
|
||||
free(h_C);
|
||||
free(reference);
|
||||
checkCudaErrors(cudaFree(d_A));
|
||||
checkCudaErrors(cudaFree(d_B));
|
||||
checkCudaErrors(cudaFree(d_C));
|
||||
|
||||
if (resCUBLAS == true) {
|
||||
return EXIT_SUCCESS; // return value = 1
|
||||
} else {
|
||||
return EXIT_FAILURE; // return value = 0
|
||||
}
|
||||
if (resCUBLAS == true) {
|
||||
return EXIT_SUCCESS; // return value = 1
|
||||
}
|
||||
else {
|
||||
return EXIT_FAILURE; // return value = 0
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Program main
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
int main(int argc, char **argv) {
|
||||
printf("[Matrix Multiply CUBLAS] - Starting...\n");
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
printf("[Matrix Multiply CUBLAS] - Starting...\n");
|
||||
|
||||
int devID = 0, sizeMult = 5;
|
||||
sMatrixSize matrix_size;
|
||||
int devID = 0, sizeMult = 5;
|
||||
sMatrixSize matrix_size;
|
||||
|
||||
initializeCUDA(argc, argv, devID, sizeMult, matrix_size);
|
||||
initializeCUDA(argc, argv, devID, sizeMult, matrix_size);
|
||||
|
||||
int matrix_result = matrixMultiply(argc, argv, devID, matrix_size);
|
||||
int matrix_result = matrixMultiply(argc, argv, devID, matrix_size);
|
||||
|
||||
return matrix_result;
|
||||
return matrix_result;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user