#include "cuda_runtime.h" 
#include "cublas_v2.h" 

#include <time.h> 
#include <iostream> 

using namespace std;

// 定義測試矩陣的維度 
int const M = 5;
int const N = 10;

int main()
{
	// 定義狀態變數 
	cublasStatus_t status;

	// 在 記憶體 中為將要計算的矩陣開闢空間 
	float *h_A = (float*)malloc(N*M * sizeof(float));
	float *h_B = (float*)malloc(N*M * sizeof(float));

	// 在 記憶體 中為將要存放運算結果的矩陣開闢空間 
	float *h_C = (float*)malloc(M*M * sizeof(float));

	// 為待運算矩陣的元素賦予 0-10 範圍內的隨機數 
	for (int i = 0; i < N*M; i++) {
		h_A[i] = (float)(rand() % 10 + 1);
		h_B[i] = (float)(rand() % 10 + 1);

	}

	// 列印待測試的矩陣 
	cout << "矩陣 A :" << endl;
	for (int i = 0; i < N*M; i++) {
		cout << h_A[i] << " ";
		if ((i + 1) % N == 0) cout << endl;
	}
	cout << endl;
	cout << "矩陣 B :" << endl;
	for (int i = 0; i < N*M; i++) {
		cout << h_B[i] << " ";
		if ((i + 1) % M == 0) cout << endl;
	}
	cout << endl;

	/*
	** GPU 計算矩陣相乘
	*/

	// 建立並初始化 CUBLAS 庫物件 
	cublasHandle_t handle;
	status = cublasCreate(&handle);

	if (status != CUBLAS_STATUS_SUCCESS)
	{
		if (status == CUBLAS_STATUS_NOT_INITIALIZED) {
			cout << "CUBLAS 物件例項化出錯" << endl;
		}
		getchar();
		return EXIT_FAILURE;
	}

	float *d_A,*d_B,*d_C;
	// 在 視訊記憶體 中為將要計算的矩陣開闢空間 
	cudaMalloc(
		(void**)&d_A,// 指向開闢的空間的指標 
		N*M * sizeof(float)  //　需要開闢空間的位元組數 
	);
	cudaMalloc(
		(void**)&d_B,N*M * sizeof(float)
	);

	// 在 視訊記憶體 中為將要存放運算結果的矩陣開闢空間 
	cudaMalloc(
		(void**)&d_C,M*M * sizeof(float)
	);

	// 將矩陣資料傳遞進 視訊記憶體 中已經開闢好了的空間 
	cublasSetVector(
		N*M,// 要存入視訊記憶體的元素個數 
		sizeof(float),// 每個元素大小 
		h_A,// 主機端起始地址 
		1,// 連續元素之間的儲存間隔 
		d_A,// GPU 端起始地址 
		1  // 連續元素之間的儲存間隔 
	);
	cublasSetVector(
		N*M,sizeof(float),h_B,1,d_B,1
	);

	// 同步函式 
	cudaThreadSynchronize();

	// 傳遞進矩陣相乘函式中的引數，具體含義請參考函式手冊。 
	float a = 1; float b = 0;
	// 矩陣相乘。該函式必然將陣列解析成列優先陣列 
	cublasSgemm(
		handle,// blas 庫物件  
		CUBLAS_OP_T,// 矩陣 A 屬性引數 
		CUBLAS_OP_T,// 矩陣 B 屬性引數 
		M,// A,C 的行數  
		M,// B,C 的列數 
		N,// A 的列數和 B 的行數 
		&a,// 運算式的 α 值 
		d_A,// A 在視訊記憶體中的地址 
		N,// lda 
		d_B,// B 在視訊記憶體中的地址 
		M,// ldb 
		&b,// 運算式的 β 值 
		d_C,// C 在視訊記憶體中的地址(結果矩陣) 
		M  // ldc 
	);

	// 同步函式 
	cudaThreadSynchronize();

	// 從 視訊記憶體 中取出運算結果至 記憶體中去 
	cublasGetVector(
		M*M,// 要取出元素的個數 
		sizeof(float),// 每個元素大小 
		d_C,// GPU 端起始地址 
		1,// 連續元素之間的儲存間隔 
		h_C,// 主機端起始地址 
		1  // 連續元素之間的儲存間隔 
	);

	// 列印運算結果 
	cout << "計算結果的轉置 ( (A*B)的轉置 )：" << endl;

	for (int i = 0; i < M*M; i++) {
		cout << h_C[i] << " ";
		if ((i + 1) % M == 0) cout << endl;
	}

	// 清理掉使用過的記憶體 
	free(h_A);
	free(h_B);
	free(h_C);
	cudaFree(d_A);
	cudaFree(d_B);
	cudaFree(d_C);

	// 釋放 CUBLAS 庫物件 
	cublasDestroy(handle);

	getchar();

	return 0;
}

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>

int main() {
	int deviceCount;
	cudaGetDeviceCount(&deviceCount);

	int dev;
	for (dev = 0; dev < deviceCount; dev++)
	{
		int driver_version(0),runtime_version(0);
		cudaDeviceProp deviceProp;
		cudaGetDeviceProperties(&deviceProp,dev);
		if (dev == 0)
			if (deviceProp.minor = 9999 && deviceProp.major == 9999)
				printf("\n");
		printf("\nDevice%d:\"%s\"\n",dev,deviceProp.name);
		cudaDriverGetVersion(&driver_version);
		printf("CUDA驅動版本:                  %d.%d\n",driver_version / 1000,(driver_version % 1000) / 10);
		cudaRuntimeGetVersion(&runtime_version);
		printf("CUDA執行時版本:                 %d.%d\n",runtime_version / 1000,(runtime_version % 1000) / 10);
		printf("裝置計算能力:                  %d.%d\n",deviceProp.major,deviceProp.minor);
		printf("Total amount of Global Memory:         %u bytes\n",deviceProp.totalGlobalMem);
		printf("Number of SMs:                 %d\n",deviceProp.multiProcessorCount);
		printf("Total amount of Constant Memory:        %u bytes\n",deviceProp.totalConstMem);
		printf("Total amount of Shared Memory per block:    %u bytes\n",deviceProp.sharedMemPerBlock);
		printf("Total number of registers available per block: %d\n",deviceProp.regsPerBlock);
		printf("Warp size:                   %d\n",deviceProp.warpSize);
		printf("Maximum number of threads per SM:        %d\n",deviceProp.maxThreadsPerMultiProcessor);
		printf("Maximum number of threads per block:      %d\n",deviceProp.maxThreadsPerBlock);
		printf("Maximum size of each dimension of a block:   %d x %d x %d\n",deviceProp.maxThreadsDim[0],deviceProp.maxThreadsDim[1],deviceProp.maxThreadsDim[2]);
		printf("Maximum size of each dimension of a grid:    %d x %d x %d\n",deviceProp.maxGridSize[0],deviceProp.maxGridSize[1],deviceProp.maxGridSize[2]);
		printf("Maximum memory pitch:              %u bytes\n",deviceProp.memPitch);
		printf("Texture alignmemt:               %u bytes\n",deviceProp.texturePitchAlignment);
		printf("Clock rate:                   %.2f GHz\n",deviceProp.clockRate * 1e-6f);
		printf("Memory Clock rate:               %.0f MHz\n",deviceProp.memoryClockRate * 1e-3f);
		printf("Memory Bus Width:                %d-bit\n",deviceProp.memoryBusWidth);
	}

	return 0;
}