GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)

GPGPU講習会
GPU最適化ライブラリの利用（その１）
長岡技術科学大学電気電子情報工学専攻出川智啓

本講習会の目標
 GPGPU先端シミュレーションシステムの使用方法の
習得
 GPUの活用方法の修得
 CUDAプログラミング技法の修得
 並列計算手法の修得
2015/10/14GPGPU講習会2

本日の内容
 GPU最適化ライブラリの利用（その１）
 GPU最適化ライブラリの紹介
 共役勾配法（およびKrylov部分空間法）
 cuBLASの紹介
 cuBLASによる共役勾配法の実装
 連立一次方程式を解くプログラムの作成
 ライブラリを利用
 関数(およびCUDA API)の呼出のみで作成
 3回に分けて徐々に効率化

ライブラリ
 特定の処理を行う複数のプログラムを再利用可能な形
でまとめた集合体
 動画像処理やファイル圧縮，数値計算などが有名
 自作のプログラムよりも性能が高いため，関数を置き換
えるだけで処理速度の向上に貢献

数値計算ライブラリ
 FFT（Fast Fourier Transform）
 FFTW
 線形代数演算（ベクトル処理，行列処理）
 BLAS（Basic Linear Algebra Subprogram）
 BLASを利用した線形代数演算ライブラリ
 LAPACK
 LINPACK
 ScaLAPACK
 BLASやLAPACKのメーカー別実装
 MKL Intel Math Kernel Library
 ACML AMD Core Math Library
 IMSL International Mathematics and Statistics Library

CUDA付属のライブラリ
 cuBLAS 密行列向け線形代数演算
 cuSPARSE 疎行列向け線形代数演算
 cuFFT フーリエ変換
 cuRAND 乱数生成
 Thrust ソート，縮約，スキャン等
 NPP 画像処理，信号処理
など
 NVIDIAホームページに一覧がある
https://developer.nvidia.com/gpu‐accelerated‐libraries

その他GPU向けライブラリ
 cuDNN
 https://developer.nvidia.com/cudnn
 Deep Neural Network用のライブラリ
 機械学習用のフレームワークをサポート
 Caffe
 Theano
 Torch
 cuDNNを使ったDIGITSというシステムを利用してNeural
Networkのトレーニングを行うことが可能

 MAGMA
 http://icl.cs.utk.edu/magma/
 NVIDIA GPU向けの線形代数ライブラリ
 CPUも同時に使うハイブリッド型のライブラリであるため，
GPU単体より高速
 BLAS, LAPACKに準ずるような形で関数形が定められて
いる
 cuBLASに取り込まれている関数もある
 ソースコードが配布されており，無料で入手できる

 cuBLAS‐XT
 https://developer.nvidia.com/cublasxt
 cuBLASライブラリのマルチGPU向け実装
 CUDA 6.0, 6.5から利用可能

数値シミュレーションと連立一次方程式
 数値シミュレーション
 自然現象を記述する偏微分方程式の解を求める
 微積分を計算機で形に変換（離散化）
 離散化方法
 有限差分法
 空間に飛び飛びの点（離散点）を配置し，その点上で物理量を定義
 微分を差分に置き換え，離散点での物理量を使って微分を計算
 有限要素法
 空間を要素と呼ばれる微小な空間に分割
 要素内での物理量変化を基底関数で定義し，空間全体の物理量変
化を基底関数の結合として表現

 空間の平衡状態の計算
 水・空気中の圧力分布
 物体中の温度分布
 金属材料が受ける応力分布
 逆問題
 物理量が従う式だけが分かっていて，物理量の値が不明
 Laplace/Poisson方程式
?2
2
2
2






y
f
x
f
f 02
2
2
2






y
f
x
f
?f
逆問題順問題

 空間の平衡状態の計算
 水・空気中の圧力分布
 物体中の温度分布
 金属材料が受ける応力分布
 逆問題
 物理量が従う式だけが分かっていて，物理量の値が不明
 ある点での値の変化が他の点にも影響
 連立一次方程式を作成して全点の値を同時に求める
 方程式を解く時間が数値シミュレーションの大半を占める
 シミュレーションの規模が大きくなると連立一次方程式の規模も大き
くなる

連立一次方程式の解法
 直接法
 係数行列を単位行列（や上三角，下三角行列）に変形するこ
とで未知数を求める方法
 所定の計算回数で解が得られる
 計算量が多く，大規模な問題には適用が難しい
 反復法
 係数行列を変更せず，未知数に推定値を代入して所定の計
算を行い，推定値が解に十分近づくまで計算を繰り返す方法
 よい推定値を選べば非常に高速に解が得られる

共役勾配法
 連立一次方程式を解くためのアルゴリズム
 係数行列が対称・正定値である連立一次方程式が対象
 Hestenes and Stiefel(1952)によって提案
 反復解法の性質を持ちながら，直接解法のように有限回の計
算で解が得られる
 「世紀の大解法」ともてはやされた
 丸め誤差に弱く，有限回の計算で終わらないこともある
Hestenes, Magnus R., Stiefel, Eduard (December, 1952). "Methods of Conjugate Gradients for
Solving Linear Systems". Journal of Research of the National Bureau of Standards 49 (6).

共役勾配法のアルゴリズム
 連立一次方程式Ax=bに対する共役勾配法
Ap 係数行列Aと
ベクトルpの積
( , ) ベクトル同士の
内積
Compute r(0)=b−Ax(0). Set p(0)=0,c2
(0)=0.
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)p(k−1)
c1
(k) = (r(k), r(k))/(p(k), Ap(k))
x(k+1) = x(k)+c1
(k)p(k)
r(k+1) = r(k)−c1
(k)Ap(k)
c2
(k) = (r(k+1), r(k+1))/{c1
(k)(p(k), Ap(k))}
EndDo
A 係数行列
x 解ベクトル
b 右辺ベクトル
r 残差ベクトル
p 補助ベクトル
||・|| l2−ノルム

共役勾配法のバリエーション
 自乗共役勾配法（CGS法）
 非対称行列に対応
(0)=0, r*=r(0).
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)z(k−1)
u(k) = p(k)+c2
(k−1)(z(k−1)+c2
(k−1)u(k−1))
c1
(k) = (r*, r(k))/(r*, Au(k))
z(k) = p(k)−c1
(k)Au(k)
x(k+1) = x(k)+c1
(k)(p(k)+z(k))
r(k+1) = r(k)−c1
(k)A(p(k)+z(k))
c2
(k) = (r*, r(k+1))/{c1
(k)(r*, Au(k))}
EndDo
r* 疑似残差
u 補助ベクトル
z 補助ベクトル

共役勾配法のバリエーション
 安定化双共役勾配法（Bi‐CGSTAB法）
 非対称行列に対応
(0)=0, r*=r(0).
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)(p(k−1)−c3
(k−1)Ap(k−1))
c1
(k) = (r*, r(k))/(r*, Ap(k))
t(k) = r(k)−c1
(k)Ap(k)
c3
(k) = (At(k), t(k))/(At(k), At(k))
x(k+1) = x(k)+c1
(k)p(k)+c3
(k)t(k)
r(k+1) = r(k)−c3
(k)At(k)
c2
(k) = (r*, r(k+1))/{c3
(k)(r*, Ap(k))}
EndDo
r* 疑似残差
t 補助ベクトル

連立一次方程式
 3重対角行列
 2次元Poisson方程式から導かれる係数行列を簡略化
 解(x)が0, 1, 2・・・N−1となるようbを設定






















































N
N
N
N
b
b
b
b
x
x
x
x
1
2
1
1
2
1
41
141
141
14

0
0

CPUプログラム（制御部分）
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
int main(void){
int N = 1 << 10;          //未知数の数210
const double err_tol = 1e‐9; //許容誤差
const int max_ite = 1<<20;//反復回数の上限
double *x; //近似解ベクトル
double *b; //右辺ベクトル
double *A; //係数行列
double *sol; //厳密解
double *r, rr; //残差ベクトル, 残差の内積
double *p, *Ax; //補助ベクトル，行列ベクトル積
double c1, c2, dot; //計算に使う係数
int i, k;
//メモリの確保
A = (double *)malloc(sizeof(double)*N*N);
x = (double *)malloc(sizeof(double)*N);
b = (double *)malloc(sizeof(double)*N);
sol= (double *)malloc(sizeof(double)*N);
r  = (double *)malloc(sizeof(double)*N);
p  = (double *)malloc(sizeof(double)*N);
Ax = (double *)malloc(sizeof(double)*N);
for (i = 0; i < N; i++){
sol[i] = (double)i; //厳密解を設定
x[i] = 0.0;       //近似解を0で初期化
}
//係数行列Aの生成
setTridiagonalMatrix(A, N);
//右辺ベクトルbの生成
setRightHandSideVector(b, A, sol, N);
//        :
// ここで共役勾配法を実行
//        :
//確保したメモリを解放
free(x);
free(b);
free(A);
free(sol);
free(r);
free(p);
free(Ax);
} cg_cpu.c

CPUプログラム（係数行列の生成）
void setTridiagonalMatrix(double *A, int N){
int i,j;
for (j = 0; j < N; j++){
for (i = 0; i < N; i++){
A[i+N*j] = 0.0;
}
}
i = 0;
A[i + N*i  ] = ‐4.0;
A[i + N*i+1] =  1.0;
for(i = 1; i < N‐1; i++){
A[i + N*i‐1] =  1.0;
A[i + N*i  ] = ‐4.0;
A[i + N*i+1] =  1.0;
}
i = N‐1;
A[i + N*i‐1] =  1.0;
A[i + N*i  ] = ‐4.0;
}




















41
141
141
14

cg_cpu.c
i
j

CPUプログラム（右辺ベクトルの生成）
void setRightHandSideVector(double *b, double *A, double *x, int N){
int i,j;
for (i = 0; i < N; i++){
b[i] = 0.0;
for (j = 0; j < N; j++){ //係数行列と厳密解ベクトルを用いて行列－ベクトル積を計算し，
b[i] += A[i + N*j] * x[j]; //結果を右辺ベクトルに代入
}
}
}
cg_cpu.c

CPUプログラム（共役勾配法部分）
//残差ベクトルの計算 r(0)=b−Ax(0)
computeResidual(r, b, A, x, N);
//残差ベクトルの内積を計算
rr = innerProduct(r, r, N);
k = 1;
while(rr>err_tol*err_tol && k<=max_ite)
{
if (k == 1){
//p(k) = r(k)+c2
(k−1)p(k−1) c2とpが0のためp(k) = r(k)
copy(p, r, N);
}
else{
c2 = rr / (c1*dot);
//p(k) = r(k)+c2
(k−1)p(k−1)
computeVectorAdd(p, c2, r, 1.0, N);
}
//(p(k), Ap(k))を計算
//行列ベクトル積Apを実行し，結果とpの内積
computeMxV(Ax, A, p, N);
dot = innerProduct(p, Ax, N);
c1 = rr / dot;
//x(k+1) = x(k)+c1
(k)p(k)
//r(k+1) = r(k)−c1
(k)Ap(k)
computeVectorAdd(x, 1.0, p, c1, N);
computeVectorAdd(r, 1.0, Ax,‐c1, N);
k++;
}
/*
(0)=0.
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)p(k−1)
c1
(k) = (r(k), r(k))/(p(k), Ap(k))
x(k+1) = x(k)+c1
(k)p(k)
r(k+1) = r(k)−c1
(k)Ap(k)
c2
(k) = (r(k+1), r(k+1))/{c1
(k)(p(k), Ap(k))}
EndDo
*/ cg_cpu.c

CPUプログラム（共役勾配法内の関数）
//残差ベクトルr(0)=b−Ax(0)の計算
void computeResidual(double *r, double *b,
double *A, double *x,
int N){
int i,j;
double Ax;
for (i = 0; i < N; i++){
Ax = 0.0;
for (j = 0; j < N; j++){
Ax += A[i + N*j] * x[j];
}
r[i] = b[i]‐Ax;
}
}
//内積の計算
double innerProduct(double *vec1,
double *vec2, int N){
int i;
double dot;
dot=0.0;
for (i = 0; i < N; i++){
dot += vec1[i]*vec2[i];
}
return dot;
}
cg_cpu.c

CPUプログラム（共役勾配法内の関数）
//値のコピー（単純代入）p(k) = r(k)
void copy(double *lhs, double *rhs, int N){
int i;
for (i = 0; i < N; i++){
lhs[i] = rhs[i];
}
}
//ベクトル和y(k) = ax(k) + by(k)の計算
void computeVectorAdd(
double *y, const double b,
double *x, const double a,
int N){
int i;
for (i = 0; i < N; i++){
y[i] = a*x[i] + b*y[i];
}
}
//行列－ベクトル積Axの計算
void computeMxV(double *Ax,
double *A, double *x, int N){
int i,j;
for (i = 0; i < N; i++){
Ax[i] = 0.0;
for (j = 0; j < N; j++){
Ax[i] += A[i + N*j] * x[j];
}
}
}
cg_cpu.c

実行結果（N=210）
iteration =   1, residual = 2.098826e+003
:
iteration =  21, residual = 5.547180e‐009
x[0] = ‐0.000000
x[1] = 1.000000
x[2] = 2.000000
:
x[1021] = 1021.000000
x[1022] = 1022.000000
x[1023] = 1023.000000
Total amount of Absolute Error = 5.009568e‐010

収束履歴
反復回数
残差

cuBLAS*
 BLASのGPU向け実装
 Level 1
 ベクトルに対する計算
 Level 2
 行列－ベクトルの計算
 Level 3
 行列－行列の計算
 BLASはFORTRAN用ライブラリとして開発
 C言語から使用する場合には注意が必要
 配列の添字は1から
 メモリの配置がC言語と異なる
*CUBLASやcublasと書かれる事もあるが，NVIDIAの
CUDA Toolkit Documentationの標記に従う

cuBLAS
 関数群はドキュメントを参照
 http://docs.nvidia.com/cuda/cublas/
 実行する際の並列度の設定は自動
 処理内容に対応した関数を呼び出す
 cublas<>axpy()
 <>は用いる型に応じて選択
 S 単精度実数
 D 倍精度実数
 C 単精度複素数型
 Z 倍精度複素数型

cuBLAS
 計算内容に対応した関数を呼ぶ事で計算を実行
 cublas<>axpy() ベクトル和
 cublas<>gemv() 行列‐ベクトル積
 cublas<>gemm() 行列‐行列積
 コンパイルの際はオプションとして –lcublas を追加
y[] = x[] + y[]
y[] = OP(A[][])x[] + y[]
C[][] = OP(A[][])OP(B[][]) + C[][]
OP(A[][])は行列Aに
対する処理（転置など）

#include<stdio.h>
#include<math.h>
#include<cublas_v2.h>
#define N 256
int main(){
int i,j;
float A[N*N], B[N], C[N];
float *d_A, *d_B, *d_C;
float alpha, beta;
for(j=0;j<N;j++){
for(i=0;i<N;i++){
A[i+N*j] = (float)i/(float)N;
}
}
for(i=0;i<N;i++){
C[i] = 0.0f;
}
for(i=0;i<N;i++){
B[i] = 1.0f;
}
cudaMalloc
((void**)&d_A, N*N*sizeof(float));
cudaMalloc
((void**)&d_B, N*sizeof(float));
cudaMalloc
((void**)&d_C, N*sizeof(float));
alpha = 1.0f;
beta = 0.0f;
cuBLASによる行列－ベクトル積
GPGPU講習会33 2015/10/14
cublas_gemv.cu















































1
1
1
256/2256/2256/2
256/1256/1256/1
256/0256/0256/0
]2[
]1[
]0[
c
c
c

cublasHandle_t handle;
cublasCreate(&handle);
cublasSetMatrix
(N, N, sizeof(float), A, N, d_A, N);
cublasSetVector
(N, sizeof(float), B, 1, d_B, 1);
cublasSetVector
(N, sizeof(float), C, 1, d_C, 1);
cublasSgemv
(handle, CUBLAS_OP_N, N, N, &alpha,
d_A, N, d_B, 1, &beta, d_C, 1);
cublasGetVector
(N, sizeof(float), d_C, 1, C, 1);
for(i=0;i<N;i++){
printf("C[%3d] = %f ¥n",j, C[j]);
}
cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);
cublasDestroy(handle);
return 0;
}
GPGPU講習会34 2015/10/14
cublas_gemv.cu

 ヘッダファイルのインクルード
 #include<cublas_v2.h>
 CUBLASのハンドルの作成
 cublasHandle_t handle;
 cublasCreate(&handle);
 ハンドル（行列やベクトルの情報を管理）の生成
 返値はcublasStatus_t型
 GPU上のメモリ確保
 cudaMalloc
 以前はcublasAlloc()という関数もあったが無くなった

 データ転送
 cublasSetMatrix(N,N,sizeof(float),A,N,d_A,N);
 cublasSetVector(N,sizeof(float),B,1,d_B,1);
 cublasSetVector(N,sizeof(float),C,1,d_C,1);
 関数内部でcudaMemcpyが呼ばれるそれぞれB,d_B,
C, d_Cにアクセス
する際のストライド
行列(A, d_A)の第1次元の要素数

 演算を行う関数の呼び出し
 cublasSgemv(handle, CUBLAS_OP_N, N, N, &alpha,
d_A, N, d_B, 1, &beta, d_C, 1);
 CUBLAS_OP_N 行列Aに対する操作
 cublasOperation_t型
 CUBLAS_OP_N OP(A)＝A 処理しない
 CUBLAS_OP_T OP(A)＝AT 転置
 CUBLAS_OP_C OP(A)＝AH 共役転置
C[N] = OP(A[N][N])B[N] + C[N]
d_B, d_C
にアクセス
する際のス
トライド
行列d_Aの第1次元の要素数

 データの読み戻し
 cublasGetVector(N,sizeof(float),d_C,1,C,1);
 GPU上のメモリの解放
 cudaFree
 ハンドルの削除
 cublasDestroy(handle);
d_C, Cにアクセス
する際のストライド

cuBLASを使う際の注意点
 行列を表現するときのメモリ配置
 A[i][j]
 2次元配列でもメモリ上は1次元に配置
 i方向が先かj方向が先か
 C言語はj方向優先
 Fortranはi方向優先

 C言語におけるA[i][j]のメモリ上の配置
 0/256,0/256,0/256･･･1/256,1/256,1/256･･･2/256,2/256,2/256 ･･･
 FortranにおけるA(i,j)のメモリ上の配置
 0/256,1/256,2/256･･･0/256,1/256,2/256･･･0/256,1/256,2/256･･･


















256/2256/2256/2
256/1256/1256/1
256/0256/0256/0
j
i

 0/256,0/256,0/256･･･1/256,1/256,1/256･･･2/256,2/256,2/256 ･･･
 FortranにおけるA(i,j)のメモリ上の配置
 0/256,1/256,2/256･･･0/256,1/256,2/256･･･0/256,1/256,2/256･･･


















256/2256/2256/2
256/1256/1256/1
256/0256/0256/0
j
i

 0/256,0/256,0/256･･･1/256,1/256,1/256･･･2/256,2/256,2/256 ･･･
 FortranにおけるA(i,j)のメモリ上の配置 ←cuBLAS
 0/256,1/256,2/256･･･0/256,1/256,2/256･･･0/256,1/256,2/256･･･


















256/2256/2256/2
256/1256/1256/1
256/0256/0256/0
j
i

第1次元の要素数（lda）とは？
 Leading dimension of matrix A
 行列Aの一部分だけを取り出せるようにするためのオプション
 M行N列の行列としてAを宣言したときのMの値
 ldaの指定を間違えると（例えば2を指定すると）











987
654
321
A M
N







6824
93571
A











987
654
321
A
行列サイズに2,2，
ldaにM(=3)を指定
行列全体を使って計算するときはldaの値=行数と覚える

cuBLASによる共役勾配法の実装

共役勾配法のアルゴリズム（再掲）
 連立一次方程式Ax=bに対する共役勾配法
(0)=0.
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)p(k−1)
c1
(k) = (r(k), r(k))/(p(k), Ap(k))
x(k+1) = x(k)+c1
(k)p(k)
r(k+1) = r(k)−c1
(k)Ap(k)
c2
(k) = (r(k+1), r(k+1))/{c1
(k)(p(k), Ap(k))}
EndDo
Ap 係数行列Aと
ベクトルpの積
( , ) ベクトル同士の
内積
A 係数行列
x 解ベクトル
b 右辺ベクトル
r 残差ベクトル
p 補助ベクトル
||・|| l2−ノルム

CPUプログラム（共役勾配法）（再掲）
computeResidual(r, b, A, x, N);
k = 1;
{
if (k == 1){
//p(k) = r(k)+c2
copy(p, r, N);
}
else{
c2 = rr / (c1*dot);
//p(k) = r(k)+c2
(k−1)p(k−1)
computeVectorAdd(p, c2, r, 1.0, N);
}
computeMxV(Ax, A, p, N);
dot = innerProduct(p, Ax, N);
c1 = rr / dot;
//x(k+1) = x(k)+c1
(k)p(k)
//r(k+1) = r(k)−c1
(k)Ap(k)
computeVectorAdd(x, 1.0, p, c1, N);
computeVectorAdd(r, 1.0, Ax,‐c1, N);
k++;
}
/*
(0)=0.
For k=1,…, until ||r||/||b|| < , Do
p(k) = r(k)+c2
(k−1)p(k−1)
c1
(k) = (r(k), r(k))/(p(k), Ap(k))
x(k+1) = x(k)+c1
(k)p(k)
r(k+1) = r(k)−c1
(k)Ap(k)
c2
(k) = (r(k+1), r(k+1))/{c1
(k)(p(k), Ap(k))}
EndDo
*/ cg_cpu.c

共役勾配法の各処理の置き換え
 共役勾配法に必要な処理とcuBLAS関数の対応
 合致する処理が無い場合は処理を分解して対応
処理 cuBLAS関数
ベクトルの代入
(y[]=x[])
cublas<>copy
ベクトルのスカラ倍
(y[]=a*y[])
cublas<>scal
ベクトル同士の和
(y[]=a*x[]+y[])
cublas<>axpy
ベクトルの内積
(y=x[]·x[])
cublas<>dot
行列－ベクトル積
(y[]=A[][]x[])
cublas<>gemv

r(0)=b−Ax(0)の置き換え
 いきなり難関
 cuBLASはベクトルを2個までしか扱えない
 3段階に分けて計算
 行列－ベクトル積を計算 r(0)=b−Ax(0)
 計算した結果を別の配列（例えばAx）に保持
 cublasDgemv
 bの値をrに代入 r(0)=r−Ax(0)
 bを使う箇所をrに置き換えることができる
 cublasDcopy
 ベクトル和を計算 r(0)=r−1×Ax(0)
 cublasDaxpy

r(0)=b−Ax(0)の置き換え
 cublasDgemv
 cublasDgemv(handle, CUBLAS_OP_N, N, N, &one,
d_A, N, d_x, 1, &zero, d_Ax, 1);
 Ax[N] = one*A[N][N]x[N] + zero*Ax[N]
 cublasDcopy
 cublasDcopy(handle, N, d_b, 1, d_r, 1);
 r[N] = b[N]
 cublasDaxpy
 cublasDaxpy(handle, N, &minusOne,d_Ax,1 ,d_r,1);
 r[N] = r[N] + minusOne*Ax[N]
one =1.0;
zero=0.0;
minusOne =‐1.0;
必ず変数のアドレスを指定

r(0)の内積の計算
 cublasDdot
 cublasDdot(handle, N, d_r, 1, d_r, 1, &rr);
 rr = (r[N], r[N])

p(k) = r(k)+c2
(k−1)p(k−1)の置き換え
 k=1
 c2=0のため単純な代入 p(k) = r(m)
 cublasDcopy
 k>1
 ベクトル和を計算 p(k) = r(k)+c2
(k−1)p(k−1)
 またもや難題
 cublasDaxpyでは足されるベクトル(p)への操作はできない
 2段階に分けて処理を実行
 pの値をc2倍 p(k)=c2×p(k−1)
 cublasDscal
 ベクトル和を計算 p(k) = p(k)+1×r(k)
 cublasDaxpy

p(k) = r(k)+c2
(k−1)p(k−1)の置き換え
 cublasDscal
 cublasDscal(handle, N, &c2, d_p, 1);
 p[N] = c2*p[N]
 cublasDaxpy
 cublasDaxpy(handle, N, &one,d_r,1 ,d_p,1);
 p[N] = one*r[N] + p[N]

係数c1の計算
 r(k)の内積は既に計算済みなので省略
 分母(p(k), Ap(k))の計算
 2段階に分けて計算
 行列－ベクトル積Ap(k)を計算
 計算した結果を別の配列（例えばAxを流用）に保持
 cublasDgemv
 pとAxの内積を計算(p(k), Ap(k))
 cublasDdot
 c1を計算

係数c1の計算
 cublasDgemv
 cublasDgemv(handle, CUBLAS_OP_N, N, N, &one,
d_A, N, d_p, 1, &zero, d_Ax, 1);
 Ax[N] = one*OP(A[N][N])p[N] + zero*Ax[N]
 cublasDdot
 cublasDdot(handle, N, d_p, 1, d_Ax, 1, &dot);
 dot = (p[N], Ax[N])
 c1 = rr/dot

解ベクトルx(k)と残差ベクトルr(k)を更新
 ベクトル和を計算 x(k+1) = x(k)+c1
(k)×p(k)
 cublasDaxpy(handle, N, &c1,d_p,1 ,d_x,1);
 x[N] = c1*p[N] + x[N]
 ベクトル和を計算 r(k+1) = r(k)−c1
(k)×Ap(k)
 既に計算した行列－ベクトル積（Ax）を利用
 cublasDaxpy(handle, N, &minusC1, d_Ax,1 ,d_r,1);
 r[N] = minusC1*Ax[N] + r[N]
minusC1 =‐c1;

係数c2の計算
 分母(p(k), Ap(k))は計算済み
 更新されたr(k+1)の内積を計算
 cublasDdot(handle, N, d_r, 1, d_r, 1, &rr);
 rr = (r[N], r[N])
 c2 = rr/(c1*dot)

GPUプログラム（制御部分）
#include <stdlib.h>
#include <stdio.h>
#include <cublas_v2.h>
int main(void){
int N = 1 << 10; //未知数の数210
const double err_tol = 1e‐9; //許容誤差
const int max_ite = 1<<20;//反復回数の上限
double *x; //近似解ベクトル
double *b; //右辺ベクトル
double *A; //係数行列
double *sol; //厳密解
//GPU用変数
double *d_x;
double *d_b;
double *d_A;
double *d_r, rr;
double *d_p, *d_Ax;
double c1, c2, minusC1, dot;
//cublasで利用する定数
const double one = 1.0;
const double zero = 0.0;
const double minusOne = ‐1.0;
int i, k;
A = (double *)malloc(sizeof(double)*N*N);
x = (double *)malloc(sizeof(double)*N);
b = (double *)malloc(sizeof(double)*N);
sol= (double *)malloc(sizeof(double)*N);
for (i = 0; i < N; i++){
sol[i] = (double)i; //厳密解を設定
x[i] = 0.0; //近似解を0で初期化
}
//係数行列Aの生成
setTridiagonalMatrix(A, N);
//右辺ベクトルbの生成
setRightHandSideVector(b, A, sol, N);
cg_cublas.cu

GPUプログラム（制御部分）
//cuBLASハンドルの生成
cublasHandle_t cublasHandle = 0;
cublasStatus_t cublasStatus;
cublasStatus=cublasCreate(&cublasHandle);
cudaMalloc
((void **)&d_A, N*N*sizeof(double));
cudaMalloc
((void **)&d_x, N  *sizeof(double));
cudaMalloc
((void **)&d_b, N  *sizeof(double));
cudaMalloc
((void **)&d_r, N  *sizeof(double));
cudaMalloc
((void **)&d_p, N  *sizeof(double));
cudaMalloc
((void **)&d_Ax,N *sizeof(double));
cublasSetMatrix
(N, N, sizeof(double), A, N, d_A, N);
cublasSetVector
(N, sizeof(double), x, 1, d_x, 1);
cublasSetVector
(N, sizeof(double), b, 1, d_b, 1);
//        :
// ここで共役勾配法を実行
//        :
//ハンドルの破棄
cublasDestroy(cublasHandle);
//確保したメモリを解放
free(x);
free(b);
free(A);
free(sol);
cudaFree(d_x);
cudaFree(d_b);
cudaFree(d_A);
cudaFree(d_r);
cudaFree(d_p);
cudaFree(d_Ax);
} cg_cublas.cu

GPUプログラム（共役勾配法部分）
cublasDgemv(cublasHandle, CUBLAS_OP_N, N, N, &one, d_A, N, d_x, 1, &zero, d_Ax, 1);
cublasDcopy(cublasHandle, N, d_b, 1, d_r, 1);
cublasDaxpy(cublasHandle, N, &minusOne, d_Ax, 1, d_r, 1);
cublasDdot(cublasHandle, N, d_r, 1, d_r, 1, &rr);
k = 1;
{
if (k == 1){
//p(k) = r(k)+c2
cublasDcopy(cublasHandle, N, d_r, 1, d_p, 1);
}
else{
c2 = rr / (c1*dot);
//p(k) = r(k)+c2
(k−1)p(k−1)
cublasDscal(cublasHandle, N, &c2, d_p, 1);
cublasDaxpy(cublasHandle, N, &one, d_r, 1, d_p, 1);
}
cg_cublas.cu

GPUプログラム（共役勾配法部分）
cublasDgemv(cublasHandle, CUBLAS_OP_N, N, N, &one, d_A, N, d_p, 1, &zero, d_Ax, 1);
cublasDdot(cublasHandle, N, d_p, 1, d_Ax, 1, &dot);
c1 = rr / dot;
//x(k+1) = x(k)+c1
(k)p(k)
//r(k+1) = r(k)−c1
(k)Ap(k)
cublasDaxpy(cublasHandle, N, &c1, d_p, 1, d_x, 1);
cublasDaxpy(cublasHandle, N, &minusC1, d_Ax, 1, d_r, 1);
cublasDdot(cublasHandle, N, d_r, 1, d_r, 1, &rr);
cudaDeviceSynchronize();
k++;
}
//計算結果をGPUからCPUへコピー
cublasGetVector(N, sizeof(double), d_x, 1, x, 1);
cg_cublas.cu

実行時間の比較
ベクトルの次元 CPU
[sec/iteration]
cuBLAS
[sec/iteration]
210 8.26×10‐3 0.553×10‐3
211 39.6×10‐3 0.865×10‐3
212 231×10‐3 1.84×10‐3
213 1.20 5.78×10‐3
214 6.06 23.0×10‐3

実行時間の比較
ベクトルの次元
1反復あたりの実行時間[sec]

改善点
 ベクトルの次元214は多いか?
 少なすぎて話にならない
 現在のシミュレーションでは220~230（数千万から数億）
 行列の格納形式
 無駄が多い
 配列要素数に対する非ゼロ要素の割合
 (2+(N‐2)*3+2) / N2
 N=214のとき非ゼロ要素の割合は0.02%
 改善点
 行列の非ゼロ要素のみを格納してメモリ利用効率を上げる*
 cuSPARSEを利用




















41
141
141
14

0
0
*cuBLASにも帯行列‐ベクトル積を計算する関数があるので，
それを使えば0要素を保持しなくてもよくなる．調査してみよう．

A. cuBLAS関数のリファレンス
 cublasCreate
 cublasStatus_t
cublasCreate(cublasHandle_t *handle)
 cublasDestroy
 cublasStatus_t
cublasDestroy(cublasHandle_t handle)
cuBLASのハンドルのアドレス
cuBLASのハンドル

 cublasSetVector
 y[n]<‐x[n]
 cublasStatus_t
cublasSetVector(int n,
int elemSize,
const void *x,
int incx,
void *y,
int incy)
ベクトルの要素数
1要素のバイト数
コピー元ベクトルのアドレス
コピー元ベクトルのストライド
コピー先ベクトルのアドレス
コピー先ベクトルのストライド

 cublasGetVector
 y[n]<‐x[n]
 cublasStatus_t
cublasGetVector(int n,
int elemSize,
const void *x,
int incx,
void *y,
int incy)

 cublasSetMatrix
 B[rows][cols]<‐A[rows][cols]
 cublasStatus_t
cublasSetMatrix(int rows,
int cols,
int elemSize,
const void *A,
int lda,
void *B,
int ldb)
行の要素数
列の要素数
コピー元行列のアドレス
コピー元行列の1次元の要素数
コピー先行列のアドレス
コピー先行列の1次元の要素数

 cublasGetMatrix
 B[rows][cols]<‐A[rows][cols]
 cublasStatus_t
cublasGetMatrix(int rows,
int cols,
int elemSize,
const void *A,
int lda,
void *B,
int ldb)
行の要素数
列の要素数
コピー元行列のアドレス
コピー元行列の1次元の要素数
コピー先行列のアドレス
コピー先行列の1次元の要素数

 cublasDcopy
 y[n]<‐x[n]
 cublasStatus_t
cublasDcopy(cublasHandle_t handle,
int n,
const double *x,
int incx,
double *y,
int incy)
ハンドル

 cublasDdot
 result <‐ (x[n]·y[n])
 cublasStatus_t
cublasDdot (cublasHandle_t handle,
int n,
const double *x,
int incx,
const double *y,
int incy,
double *result)
ハンドル
一つ目のベクトルのアドレス
一つ目のベクトルのストライド
二つ目のベクトルのアドレス
二つ目のベクトルのストライド
内積の結果を格納する変数
のアドレス

 cublasDscal
 x[n]<‐alpha*x[n]
 cublasStatus_t
cublasDscal(cublasHandle_t handle,
int n,
const double *alpha,
double *x,
int incx)
ハンドル
かける数を代入した変数の
アドレス
入出力ベクトルのアドレス
入出力ベクトルのストライド

 cublasDaxpy
 y[n]<‐alpha*x[n] + y[n]
 cublasStatus_t
cublasDaxpy(cublasHandle_t handle,
int n,
const double *x,
int incx,
double *y,
int incy)
ハンドル
かける数を代入した変数の
アドレス
加算するベクトルのアドレス
加算するベクトルのストライド
加算されるベクトルのアドレス
加算されるベクトルのストライド

 cublasDgemv
 y[m] = alpha*OP(A[m][n])x[n] + beta*y[m]
 cublasStatus_t
cublasDgemv(cublasHandle_t handle,
cublasOperation_t trans,
int m, int n,
const double *A, int lda,
const double *x, int incx,
const double *beta,
double *y, int incy)
ハンドル
行列に対する操作
行列の行と列の要素数
かける数を代入した
変数のアドレス
行列と1次元の要素数
行列にかけるベクトル
のアドレスとストライド
計算結果のベクトルにかける
数を代入した変数のアドレス
計算結果のベクトルの
アドレスとストライド

B. 実行時間の測定
GPGPU講習会75
#include<time.h> // clock_t型や関数clock()を利用
int main(void){
clock_t start_c, stop_c;
float time_s;
start_c = clock(); //プログラム実行時からの経過時間を取得
: //
: //ここに処理を記述
: //
stop_c = clock(); //プログラム実行時からの経過時間を取得
//処理に要した時間を秒に変換
time_s = (stop_c‐start_c)/(float)CLOCKS_PER_SEC;
printf(...); //画面表示
return 0;
}
2015/10/14

B. 実行時間の測定
 CPUで時間計測はできない
 clock関数を使うと実行時間を正しく測定できない
 CUDAで用意されている関数を使って時間を計測
初期化の指示
初期化
カーネルの実行指示
カーネルを実行
結果の取得
実行結果をコピー
time
CPUとGPUは非同期
CPUは別の処理を実行可能
必要なデータのコピー
メモリに書込

C. CPUコードの実行時間の測定
#include<time.h> // clock_t型や関数clock()を利用
int main(void){
clock_t start_c, stop_c;
float time_s;
start_c = clock(); //プログラム実行時からの経過時間を取得
: //
: //ここに処理を記述
: //
stop_c = clock(); //プログラム実行時からの経過時間を取得
//処理に要した時間を秒に変換
time_s = (stop_c‐start_c)/(float)CLOCKS_PER_SEC;
printf(...); //画面表示
return 0;
}

D. CUDA Eventで時間測定*
 GPUへの指示をEventと呼び，そのEventが発生した時間の差
から時間を測定
 準備
 どのEventを取り扱うかを宣言
 kernelの呼び出し（startイベント）と実行終了（stopイベント）
 イベントを取り扱う変数の宣言と利用準備
*http://gpu.fixstars.com/index.php/
CUDA_Eventで時間計測
cudaEvent_t start,stop; ・・・イベントを取り扱う変数
float elapsed_time_ms = 0.0f; ・・・経過時間保存用
cudaEventCreate(&start); ・・・イベントのクリエイト
cudaEventCreate(&stop);

D. CUDA Eventで時間測定
 Event発生時間を記録
 Eventの同期
 startとstopの時間を正しく記録し終わっていることを保証
cudaEventRecord(start, 0);
//ここでkernelを実行
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);

 Eventが発生した時間差を計算（ミリ秒単位）
 Eventの時間を記録した変数を破棄
cudaEventElapsedTime(&elapsed_time_ms, start,stop);
cudaEventDestroy(start);
cudaEventDestroy(stop);

int main(void){
float *a,*b,*c;
//イベント記録の準備
cudaMalloc((void **)&a, Nbytes);
cudaMalloc((void **)&b, Nbytes);
cudaMalloc((void **)&c, Nbytes);
init<<< , >>>(a,b,c);
//イベント発生時間の記録
add<<< , >>>(a,b,c);
//イベント発生時間の記録
//イベントの同期
//イベント間の時間差を計算
printf("%f¥n", elapsed_time_ms);
//イベントの破棄
return 0;
}

GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS)

Similar to GPGPU Seminar (GPU Accelerated Libraries, 1 of 3, cuBLAS) (20)

More from 智啓出川

More from 智啓出川 (20)