2015年度先端GPGPUシミュレーション工学特論　第4回　GPUのメモリ階層の詳細（共有メモリ）

第4回 GPUのメモリ階層の詳細
（共有メモリ）
長岡技術科学大学電気電子情報工学専攻出川智啓

今回の内容
2015/05/07先端GPGPUシミュレーション工学特論2
 GPUのメモリ
 グローバルメモリ
 共有メモリ
 バンクコンフリクト
 共有メモリを利用した配列の転置

GPU（Graphics Processing Unit）とは
 画像処理専用のハードウェア
 具体的には画像処理用のチップ
 チップ単体では販売されていない
 PCI‐Exカードで販売
 チップ単体と区別せずにGPUと呼ぶことも多い
 ノートPCに搭載
 PCI‐Exカードとして販売されるGPUには，ビデオメモリと呼ば
れるRAMが搭載

GPUの主要部品
 基盤
 画面出力端子
 電源入力端子
 GPU（チップ）+冷却部品
 メモリ
 このメモリの特性の把握が
重要
http://www.geforce.com/whats‐new/articles /introducing‐the‐geforce‐gtx‐780
に公開されている写真を基に作成
画面出力端子
PCI‐Ex端子
電源入力端子
メモリ
チップ

メモリの階層
 オフチップメモリ
 GPUのチップ外部に置かれたメモリ
 基板上に実装
 ビデオメモリ（数GB）
 オンチップメモリ
 GPUのチップ内部に置かれたメモリ
 レジスタ
 レベル1(L1)キャッシュ
 レベル2(L2)キャッシュ
高速，容量小
低速，容量大
CPUの構造に類似

メモリの階層
 CPUのメモリ階層に類似
 CPUのメモリ階層
 オフチップメインメモリ
 オンチップレジスタ，L1,L2(,L3)キャッシュ
 GPUメモリの独自の特徴
 GPUのチップから読み書き可能か
 CPUから読み書き可能か

メモリの階層
 CPUのメモリ階層
 コアごとにL2キャッシュ，全体でL3キャッシュを持つこともある
メインメモリ
L2キャッシュ
L1キャッシュ L1キャッシュ L1キャッシュ
コア
レジスタレジスタ
コア
・・・
・・・
チップ
コア

メモリの階層
 GPUのメモリ階層
 CPUにはない独自のメモリを複数持つ
グローバルメモリ
L2キャッシュ
L1キャッシュ共有メモリ
コア
レジスタ
チップ
テクスチャ
メモリ
コンスタント
メモリ
ローカル
メモリ
テクスチャ
キャッシュ
コンスタント
キャッシュ

メモリの種類
 オンチップメモリ（GPUのチップ内部のメモリ）
 高速アクセス，小容量
 CPUからはアクセス不可
 L1キャッシュと共有メモリは一定サイズを共用
L1キャッシュ/共有（シェアー
ド）メモリ
レジスタ
容量小小
速度高速高速
GPUからの
読み書き
読み書き可
ブロック内の全スレッドが同じメモリに
アクセス（データを共有する）ことが可
能*
読み書き可
各スレッドが異なるレジスタ
にアクセス
CPUからの
アクセス
読み書き不可読み書き不可
*同じメモリ，異
なるメモリにつ
いては後ろの
スライドで説明

メモリの種類
 オフチップメモリ（GPUのチップ外部のメモリ）
 低速アクセス，大容量
 CPUから直接アクセス可能
 ローカルメモリだけはアクセス不可
グローバルメモリローカルメモリテクスチャメモリコンスタントメモリ
容量大小大小
速度低速低速高速*1 高速*1
GPUからの
読み書き
読み書き可
全てのスレッドが同じ
メモリにアクセス可能*2
読み書き可
各スレッドが異なるメ
モリにアクセス*2
読み込み可
メモリにアクセス可能*2
読み込み可
メモリにアクセス*2
CPUからの
アクセス
読み書き可読み書き不可読み書き可読み書き可
*1キャッシュが効く場合
*2同じメモリ，異なるメモリについては後ろのスライドで説明

同じメモリ
 複数のスレッドがメモリアドレスを共有
 複数のスレッドが変数を共有
 他のスレッドが書き込んだデータを読むことが可能
 共有できるスレッドの範囲はメモリの種類によって変化
//a,b[]がグローバルメモリに確保されている場合*1
__global__ void kernel(...){
int i = blockIdx.x*blockDim.x + threadIdx.x;
:
b[i] = i; //スレッドiが配列要素b[i]に自身のスレッド番号を代入
//b[0,1,...,i‐1,i,...]の値は0,1,...,i‐1,i,...
a = b[i‐1];*2 //スレッドi‐1が書き込んだ値を読み*3，aに代入
: //最後に書き込まれたaの値を全スレッドが共有
} *1 あくまで動作のイメージを説明するための例で正しく実行できない
*2 iが0の場合は考えない
*3 配列bを全スレッドが共有しているので，書き込んだ値以外を読む事が可能

異なるメモリ
 メモリアドレスが共有できず，一つのスレッドのみが
そのメモリアドレスにアクセス
 あるスレッドが宣言した変数へアクセスできない
//a,b[]がレジスタに確保されている場合*1
__global__ void kernel(...){
int i = blockIdx.x*blockDim.x + threadIdx.x;
:
b[i] = i; //スレッドiが配列要素b[i]に自身のスレッド番号を代入
//b[0,1,...,i‐1,i,...]の値はb[i]以外不定
a = b[i‐1];*2 //b[i‐1]の値（不定）をaに代入*3
: //aの値はスレッドによって異なる
} *1 あくまで動作のイメージを説明するための例で正しく実行できない
*2 iが0の場合は考えない
*3 配列bは他のスレッドからアクセスできないため，代入した値以外は不定のまま

 共有メモリとL1キャッシュ
は一定サイズを共用
 グローバルメモリへのアク
セスはL2キャッシュ経由*1
 Fermi世代では標準でL1
キャッシュも有効化*2
メモリの種類
オフチップメモリ
オンチップメモリ
L2キャッシュ
コンスタントメモリ
テクスチャメモリ
GPU
Chip
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
･･･
･･･
*1Tesla世代でもテクスチャキャッシュとコンスタント
キャッシュは存在
*2Kepler世代では標準でL1キャッシュが無効化
ホスト
メモリ

メモリの種類と並列化階層の対応
 オンチップメモリ
 ブロックまたはスレッドごと
に異なる値を持つ
 オフチップメモリ
 GPU全体で共通の値を持つ
 ローカルメモリはレジスタが
不足した時に使われる
各GPU(Grid)内
でデータを共有
各ブロック内で
データを共有
各スレッドが個別の
データを保有
L2キャッシュ
Grid
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
Thre
ad 0
Thre
ad 1
Thre
ad 2
Thre
ad 3
L1キャッ
シュ
共有
メモリ
Block(0,0,0)
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
Thre
ad 0
Thre
ad 1
Thre
ad 2
Thre
ad 3
L1キャッ
シュ
共有
メモリ
Block(1,0,0)
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
･･･
･･･
ホスト
メモリ

L2キャッシュ
GPU
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
･･･
･･･
 ビデオメモリ（数GB）
 CPUのメインメモリに相当
 読み込みがある一定サイ
ズでまとめて行われる
 レイテンシが大きい
 効率よくアクセスするため
の条件がある
 コアレスアクセス
 アラインアクセス
Tesla世代ではコアレスアクセスの条件に
メモリのアラインが含まれている
Chip
ホスト
メモリ

グローバルメモリへのアクセス
（Fermi世代以降）
 メモリ操作の命令はWarpごとに発行
 1 Warp内の32スレッドが協調
 各スレッドのメモリアクセス要求を一つに集約
 メモリアクセス要求の処理
 128バイトもしくは32バイト単位
 すべてL2キャッシュを通過
 アーキテクチャによってはL1キャッシュも通過
 L1キャッシュの使用はコンパイルオプションで設定可能
 Fermi世代は標準で使用，Kepler世代は標準で未使用

グローバルメモリへのアクセス
 コアレスメモリアクセス(coalesce access)
 1 Warp内の32スレッドが隣り合ったメモリにアクセス
 データサイズが4バイトの時，スレッド1がアクセスするメ
モリアドレスはスレッド0がアクセスするメモリアドレス+4
 メモリアドレスの連続性に着目
 アラインメモリアクセス(align access)
 Warpがアクセスするデータの先頭アドレスがキャッシュ粒
度の倍数
 L2キャッシュのみを使う場合は32バイトの倍数
 L1キャッシュとL2キャッシュを使う場合は128バイトの倍数

キャッシュされる読込
 L1キャッシュとL2キャッシュを通過
 読込は128バイト単位で実行
 L1キャッシュのキャッシュラインのサイズで実行
 読込の評価に利用する用語
 メモリトランザクション
 メモリのアクセス要求に対して排他的にメモリにアクセスし
て行う処理の単位
 バスの利用率
 必要なデータサイズ/読込完了に必要な読込データサイズ

 アライン/コアレスアクセス
 Warp内の全スレッドが要求するメモリアドレスが128バイトの
範囲内
 全スレッドが隣り合ったメモリにアクセス
 先頭データのメモリアドレスが128バイトの倍数
 読込に必要な128バイトのトランザクションは一つ
 読み込んだデータ全てを利用
 バスの利用率は128/128=100%
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
キャッシュされる読込の例
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8
Warp内でのスレッドID
（カーネル内でのスレッド番号とは異なる）
メモリアドレス
メモリアドレスに対するスレッドのアクセス要求
読込に必要な128バイトトランザクション
128バイトのキャッシュライン
読み込むデータ

 アライン/アンコアレスアクセス
 Warp内の全スレッドが要求するメモリアドレスが128バイト
の範囲内（一つのキャッシュラインに収まる）
 各スレッドがアクセスするメモリアドレスが不連続
 バスの利用率は128/128=100%
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 ミスアライン/コアレスアクセス
 Warpがアクセスするデータの先頭アドレスが128の倍数で
はない（一つのキャッシュラインに収まらない）
 先頭データのメモリアドレスが128バイトの倍数ではない
 読込に必要な128バイトのトランザクションは二つ
 読み込んだデータの半分だけを利用
 バスの利用率は128/(128×2)=50%
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 Warp内の全スレッドが同じアドレスにアクセス要求
 一つのキャッシュラインに収まる
 読み込んだ128バイトのうち利用されるのは4バイトのみ
 バスの利用率は4/128=3.125%
0 1 2 3 4 56 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 Warp内の各スレッドが広範囲に点在するデータにアクセス
 複数のキャッシュラインにまたがる（上の例では3個）
 読込に必要な128バイトのトランザクションは最悪で32個
 読み込んだデータのうち128バイトのみを利用
 バスの利用率は最悪で128/(128×32)=3.125%
 上の例では128/(128×3)=33.3%
 何度も読み込むための待ちが発生
0 1 2 3 4 56 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

キャッシュされない読込
 L1キャッシュを無効化
 L2キャッシュのみを通過
 読込は32バイト単位で実行
 メモリセグメントのサイズで実行
 細かい単位で実行されるため，ミスアライン・アンコアレスメ
モリアクセスのパフォーマンスが改善される可能性がある
 セグメント
 メモリの管理方式の一つ
 まとまった大きさで管理されたメモリ空間

 アライン/コアレスアクセス
（四つのセグメントに収まる）
 読込に必要な32バイトのトランザクションは四つ
 バスの利用率は128/(32×4)=100%
キャッシュされない読込の例
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8
（カーネル内でのスレッド番号とは異なる）
メモリアドレスに対するスレッドのアクセス要求
読込に必要な32バイトトランザクション
32バイトのメモリセグメント
読み込むデータ

 アライン/アンコアレスアクセス
（四つのセグメントに収まる）
 各スレッドがアクセスするメモリアドレスが不連続
 読込に必要な32バイトのトランザクションは四つ
 バスの利用率は128/(32×4)=100%
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 Warpがアクセスするデータの先頭アドレスが128の倍数で
はない（五つのセグメントにまたがる）
 先頭データのメモリアドレスが32バイトの倍数ではない
 読込に必要な32バイトのトランザクションは五つ
 読み込んだデータの8割は利用
 バスの利用率は128/(32×5)=80% 改善！
0 1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 ミスアライン/アンコアレスアクセス
 Warp内の全スレッドが同じアドレスにアクセス要求
 一つのセグメントに収まる
 読み込んだ32バイトのうち利用されるのは4バイトのみ
 バスの利用率は4/32=12.5% 改善！
0 1 2 3 4 56 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

 ミスアライン/アンコアレスアクセス
 Warp内の各スレッドが広範囲に点在するデータにアクセス
 複数のセグメントにまたがる（上の例では10個）
 読込に必要な32バイトのトランザクションは最悪で32個
 最悪でも32バイトのセグメント32個に分散
 バスの利用率は最悪で128/(32×32)=12.5% 改善！
 上の例では128/(32×10)=40% 改善！
 何度も読み込むための待ちは依然として発生
0 1 2 3 4 56 7 8 9 1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
0 1
6
3
2
4
8
6
4
8
0
9
6
1
1
2
1
2
8
1
4
4
1
6
0
1
7
6
1
9
2
2
0
8
2
2
4
2
4
0
2
5
6
2
7
2
2
8
8
3
0
4
3
2
0
3
3
6
3
5
2
3
5
8

L2キャッシュ
GPU
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
･･･
･･･
Chip
共有（シェアード）メモリ
 ブロック内のスレッドが共
通のデータ（メモリアドレ
ス）にアクセス可能
 物理的にSMに近い
 遅延はグローバルメモリの
20~30分の1,帯域幅は10倍
 Fermi世代以前のGPUで
マネージドキャッシュとして
利用
 1ブロックあたり
16,32*,48kB
*Kepler世代から
ホスト
メモリ

共有（シェアード）メモリ
 修飾子 __shared__ を付けて宣言
 データをブロック内で共有するために同期を取る
 共有メモリ上でデータを変更してもグローバルメモリ
には反映されない
 グローバルメモリへの書き戻しが必要
__global__ void kernel(flaot *a){
__shared__ float shared_a[NT];//NTはスレッド数
int i = blockDim.x*blockIdx.x + theadIdx.x;
shared_a[threadIdx.x] = a[i];
__syncthreads();
//共有メモリを使った処理
__syncrthreads();
a[i] = shared_a[threadIdx.x];
}

共有（シェアード）メモリ利用のイメージ
a[i]
a[i]
shared_a[tx]
i=   0    1   2    3   4    5   6    7
tx=threadIdx.x=   0    1   2    3   0    1   2    3
tx= 0    1   2    3     0    1   2    3
ブロック内で同期
共有メモリを使った処理
shared_a[tx]
blockIdx.x=0 blockIdx.x=1
共有メモリを使った処理
一つのブロック内
で使用する分のみ
を確保
同期を取り，共有
メモリ内に正しく
データが入ってい
ることを保証ブロック内で同期
処理の流れ

ブロック内でのスレッドの同期
 __syncthreads();
 カーネル実行中にスレッドの同期を取る
 __syncthreads()が書かれた行にスレッドが到達する
と，同一ブロック内の他の全てのスレッドがその行に達す
るまで待機
 異なるブロック間での同期は不可能
 1ブロックあたりのスレッド数が32以下では不要*
 32スレッドが一つのwarpとして協調して処理を実行するため
 ifの中に記述するとカーネルが終了しないことがある
if(条件){
__syncthreads();
//条件が真にならないスレッドはifの中に入らないため，
//カーネルが永久に終わらない
}
*Warp同期プログラミン
グは将来のGPUでサポー
トが廃止される予定

共有（シェアード）メモリの宣言
 修飾子 __shared__ を付けて宣言
 配列として宣言
 要素数を静的（コンパイル時）に決定する場合
 __shared__ 型変数名[要素数]
 多次元配列も宣言可能（1,2,3次元）
 要素数を動的（カーネル実行時）に決定する場合
 extern __shared__ 型変数名[]
 メモリサイズをカーネル呼出時のパラメータで指定
 <<<ブロック数，スレッド数，共有メモリのサイズ>>>
=要素数*sizeof(共有メモリの型)

共有（シェアード）メモリ容量の選択
 共有メモリとL1キャッシュは64kBを共用
 どちらを多く利用するかを決定する関数が用意されている
 64kB全ての利用は不可能
 L1キャッシュ48kB/共有メモリ16kB
 cudaDeviceSetCacheConfig(cudaFuncCachePreferL1);
 L1キャッシュ16kB/共有メモリ48kB
 cudaDeviceSetCacheConfig(cudaFuncCachePreferShared);
 コンパイルオプションとして ‐Xptxas ‐dlcm=cgを与えるとL1キャッ
シュを利用しなくなるが，48kB以上は利用できない
 L1キャッシュ32kB/共有メモリ32kB*
 cudaDeviceSetCacheConfig(cudaFuncCachePreferEqual);
*Kepler世代から

カーネル単位での共有メモリ容量の選択
 デバイス（GPU）単位ではなくカーネル単位で共有メモ
リの容量を決定する関数も用意
 cudaFuncSetCacheConfig(関数ポインタ，容量の設定)
 容量の設定はcudaDeviceSetCacheConfigと同じ
 cudaFuncCachePreferL1
 cudaFuncCachePreferShared
 cudaFuncCachePreferEqual*
 cudaFuncCachePreferNone（デフォルト）
 カーネルごとに一度設定するだけでよい
 デバイスごとの設定（cudaDeviceSetCacheConfig）を
上書きできる
*Kepler世代から

共有（シェアード）メモリへのアクセス
（Tesla世代）
 高速にアクセスするための制約が緩い
 16スレッド（Half Warp）単位でアクセス
 16個のバンクから構成
 32bit=4バイトが1バンク
 一つのバンクにアクセスできるのはHalf Warp内
の1スレッドのみ
 複数のスレッドが一つのバンクに同時にアクセスすると
バンクコンフリクト（バンク衝突）が発生
 共有メモリへのアクセスが逐次化される

バンクコンフリクトにならない例
（Tesla世代）
 Half Warpが
異なるバンク
にアクセス
 隣接データに
アクセス
 データのサイ
ズは32bit
(float型)
 コアレスアクセ
スに類似
 Half Warpが
異なるバンク
にアクセス
 ランダムアク
セス
 データのサイ
ズは32bit
 アドレスが不
連続でもよい
 コアレスアク
セスと異なる
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1 1
0 0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1 1
0 0
メモリアドレスに対する
スレッドのアクセス要求 Half Warp内でのスレッドID
バンク番号

 96bit(12バイト)ごと
にアクセス
 float型データ3個分の
構造体など
 同じバンクにはアクセス
していない
124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
バンクコンフリクトにならない例
（Tesla世代）
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
スレッドのアクセス要求
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号

バンクコンフリクトする例
（Tesla世代）
 64bit（8バイト）ごとに
アクセス
 double型では必ずバン
クコンフリクトが発生
 2wayバンクコンフリクト
 スレッド0と8, 1と9,2と
10...は同時に共有メ
モリにアクセスできない
124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト
バンク番号

バンクコンフリクトする例
（Tesla世代）
 256bit（32バイト）ごと
にアクセス
 8wayバンクコンフリクト
124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
252
248
244
240
236
232
228
224
220
216
212
208
204
200
196
192
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク
コンフリクト
バンク
コンフリクト
バンク番号

バンクコンフリクトしない例
（Tesla世代）
 16スレッドが一つの
バンクの同一アドレ
スにアクセス
 配列のある要素の
データを全スレッドが
共有
 バンクコンフリクトは
発生しない
 ブロードキャストが行
われる
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号

共有（シェアード）メモリへのアクセス
 32スレッド（1 Warp）単位でアクセス
 32個のバンクから構成
 Compute Capabilityが2.x 32bit=4バイトが1バンク
 帯域幅はクロックサイクルふたつあたり32ビット
 Compute Capabilityが3.x 64bit=8バイトが1バンク
 帯域幅はクロックサイクルあたり64ビット
 バンクコンフリクトはFermiと同じか少ない
 関数でバンクサイズを設定可能
 cudaDeviceSetShareMemConfig(設定);
 設定
 cudaSharedMemBankSizeFourByte 4バイト
 cudaSharedMemBankSizeEightByte 8バイト

12
8
バンクコンフリクトにならないアクセス
（Fermi世代）
 Warp内の32スレッドが異なるバンクにある32ビット
のデータに隣接アクセス
 理想的なアクセスパターン
 Warpが発行した共有メモリの読込，書込命令が一つのトラ
ンザクションで処理される
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
バンク番号 0 1 2 3
14
4
4 5 6 7
16
0
8 9 10 11
17
6
12 13 14 15
19
2
16 17 18 19
20
8
20 21 22 23
22
4
24 25 26 27
24
0
28 29 30 31

（Fermi世代）
 Warp内の32スレッドが異なるバンクにある32ビット
のデータにランダムアクセス
 各スレッドは異なるバンクにアクセス
 バンクコンフリクトは発生しない
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
12
8
0 1 2 3
14
4
4 5 6 7
16
0
8 9 10 11
17
6
12 13 14 15
19
2
16 17 18 19
20
8
20 21 22 23
22
4
24 25 26 27
24
0
28 29 30 31バンク番号

（Fermi世代）
 複数のスレッドが一つのバンクの同一アドレスにアク
セス
 バンクコンフリクトは発生しない
 メモリトランザクションが一つ実行され，アクセスした複数の
スレッドに値がブロードキャストされる
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
12
8
0 1 2 3
14
4
4 5 6 7
16
0
8 9 10 11
17
6
12 13 14 15
19
2
16 17 18 19
20
8
20 21 22 23
22
4
24 25 26 27
24
0
28 29 30 31バンク番号

バンクコンフリクトになるアクセス
（Fermi世代）
 複数のスレッドが一つのバンクの異なるアドレスにア
クセス
 バンクコンフリクトが発生（下の例では4‐way）
 メモリアクセスが逐次化（最悪で32倍の時間がかかる）
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0
12
8
25
6
38
4
0 1 2 3
16
14
4
27
2
40
0
4 5 6 7
32
16
0
28
8
41
6
8 9 10 11
48
17
6
30
4
43
2
12 13 14 15
64
19
2
32
0
44
8
16 17 18 19
80
20
8
33
6
46
4
20 21 22 23
96
22
4
35
2
48
0
24 25 26 27
11
2
24
0
35
8
49
6
28 29 30 31バンク番号
バンク
コンフリクト
バンク
コンフリクト
バンク
コンフリクト

レジスタ
 各スレッドが個別に利用
 カーネル内で変数を宣言す
るとレジスタを利用
 非常に高速
 キャッシュとしても利用可能
*Keplerからは65536本
 少容量
 32768本*×32bit
 利用可能分を超え
るとローカルメモリ
へ追い出される
 レジスタスピル
L2キャッシュ
GPU
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
レジ
スタ
レジ
スタ
レジ
スタ
レジ
スタ
CUDA
Core
CUDA
Core
CUDA
Core
CUDA
Core
L1キャッ
シュ
共有
メモリ
SM
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
ローカル
メモリ
･･･
･･･
Chip
ホスト
メモリ

並列化の階層とメモリの階層
並列化の階層メモリの階層
Grid
Block
Thread
Warp
共有メモリ
GPU
Streaming
Multiproc
essor
CUDA
Core
オフチップ
メモリ
オンチッ
プメモリ
ハードウェア
構成
ハードウェア
構成
レジスタ

共有メモリの使いどころ
 Tesla世代以前では共有メモリの利用は必須
 キャッシュを未搭載
 同じデータに2回以上アクセスする場合は共有メモリに保
持して再利用
 Fermi世代以降
 キャッシュを搭載
 単純な処理ではキャッシュが大いに活躍
 プログラマが管理できるキャッシュ
 キャッシュされない条件下で共有メモリを利用してデータを再利用
 メモリアクセスパターンの最適化
 グローバルメモリへのアクセスの制約を回避

配列（画像や行列）の転置
 読込と書込で配列へのアクセスパターンが異なる
 一方はコアレッシング可，一方はコアレッシング不可
 共有メモリを利用してメモリアクセスを改善
1 2
3 4
1 3
2 4j
i
j
i

 2次元配列の転置
out[j][i] = in[i][j]
in[][] out[][]
Ny
Nx
Nx
Ny

 1次元配列に保存されたデータの転置
out[i*Ny+j] = in[j*Nx+i]
Ny
Nx
Nx
Ny
in[] out[]

#include<stdio.h>
#include<stdlib.h>
#define Nx 4096
#define Ny 2048
#define Nbytes (Nx*Ny*sizeof(int))
void init(int *in, int *out){
int i,j;
for(i=0; i<Nx; i++){
for(j=0; j<Ny; j++){
in[i*Ny + j] = j;
out[i*Ny + j] = ‐1;
}
}
}
void transpose(int *in, int *out){
int i,j;
for(i=0; i<Nx; i++){
for(j=0; j<Ny; j++){
out[j*Nx+i] = in[i*Ny+j];
}
}
}
int main(){
int *in,*out;
in = (int *)malloc(Nbytes);
out = (int *)malloc(Nbytes);
init(in,out);
transpose(in,out);
return 0;
}
CPUプログラム
transpose.c

GPUへの移植
 2次元的に並列化し，1スレッドが1要素を転置
blockIdx.x=0 blockIdx.x=1
blockIdx.y=0blockIdx.y=1
gridDim.x=2
gridDim.y=2
blockDim.x=4
blockDim.y=4
threadIdx.x=
threadIdx.y=

1スレッドが読み込む配列要素の決定
 i = blockIdx.x*blockDim.x + threadIdx.x
 j = blockIdx.y*blockDim.y + threadIdx.y
(0,0)(1,0)(2,0)(3,0)(0,0)
(3,3) (3,3)
(0,1)(1,1)(2,1)(3,1)
(0,2)(1,2)(2,2)(3,2)
(0,3)(1,3)(2,3)(3,3) (3,3)
(0,0) (0,0)
block(0,0) block(1,0)
thread
threadIdx.x
threadIdx.y
i= 0 1 2 3 4 5 6 7
j=01234567

1スレッドが書き込む配列要素の決定
 グローバルメモリへの書込は，読込の際に設定した
ブロックやスレッドの配置に制限されない
 スレッド番号と配列添字を対応付ける便宜的な概念
in[ij] out[ij]

#include<stdio.h>
#define Nx 4096
#define Ny 2048
#define Tx 16
#define Ty 16
__global__
int i = blockIdx.x*blockDim.x
+ threadIdx.x;
int j = blockIdx.y*blockDim.y
+ threadIdx.y;
in[i*Ny + j] = j;
out[i*Ny + j] = ‐1;
}
__global__
+ threadIdx.x;
+ threadIdx.y;
out[j*Nx + i] = in[i*Ny + j];
}
int main(){
int *in,*out;
dim3 Thread(Tx,Ty,1),
Block(Nx/Tx,Ny/Ty,1);
cudaMalloc((void**)&in,Nbytes);
cudaMalloc((void**)&out,Nbytes);
init<<<Block, Thread>>>(in,out);
transpose<<<Block, Thread>>>
(in,out);
return 0;
}
GPUプログラム
simple_transpose.cu

2次元的な配列アクセスの優先方向
 x, yのどちらをメモリが連続な方向とするか
 threadIdx.xが連続な方向にアクセスする場合
(0,0)(1,0)(2,0)(3,0)(0,0)
(3,3) (3,3)
(0,1)(1,1)(2,1)(3,1)
(0,2)(1,2)(2,2)(3,2)
(0,3)(1,3)(2,3)(3,3) (3,3)
(0,0) (0,0)
 threadIdx.x=0~15,
threadIdx.y=0
 threadIdx.x=0~15,
threadIdx.y=1
...
 [i][j]=[j*Nx+i]
メモリが連続な方向
threadIdx.y
threadIdx.x

 x, yのどちらをメモリが連続な方向とするか
 threadIdx.yが連続な方向にアクセスする場合
(0,0)(1,0)(2,0)(3,0)(0,0)
(3,3) (3,3)
(0,1)(1,1)(2,1)(3,1)
(0,2)(1,2)(2,2)(3,2)
(0,3)(1,3)(2,3)(3,3) (3,3)
(0,0) (0,0)
 threadIdx.x=0,
threadIdx.y=0~15
 threadIdx.x=1,
threadIdx.y=0~15
...
 [i][j]=[i*Ny+j]
メモリが連続な方向
threadIdx.y
threadIdx.x

#include<stdio.h>
#define Nx 4096
#define Ny 2048
#define Tx 16
#define Ty 16
__global__
+ threadIdx.x;
+ threadIdx.y;
in[i*Ny + j] = j;
out[i*Ny + j] = ‐1;
}
__global__
void copy(int *in, int *out){
+ threadIdx.x;
+ threadIdx.y;
out[j*Nx + i] = in[j*Nx + i];
out[i*Ny + j] = in[i*Ny + j];
}
int main(){
int *in,*out;
copy<<<Block, Thread>>>(in,out);
return 0;
}
simple_copy.cu
どちらが高速？

実行時間
 入力配列サイズ Nx×Ny = 4096×2048
 スレッド数 Tx×Ty = 16×16
カーネル実行時間 [ms]
copy(目標値) 0.802 / 1.57

 2次元配列の場合
in[][],out[][]
Nx
Ny
j
i
for(i=0;i<Nx;i++)
for(j=0;j<Ny;j++)
out[i][j]=in[i][j];
for(j=0;j<Ny;j++)
for(i=0;i<Nx;i++)
out[i][j]=in[i][j];

 2次元配列の場合
for(i=0;i<Nx;i++)
for(j=0;j<Ny;j++)
out[i][j]=in[i][j];
in[][],out[][]
Nx
Ny
j
i
for(j=0;j<Ny;j++)
for(i=0;i<Nx;i++)
out[i][j]=in[i][j];

 2次元配列の1次元配列的表現（前回資料参照）
for(i=0;i<Nx;i++)
for(j=0;j<Ny;j++)
out[i][j]=in[i][j];
in[],out[]
Nx
Ny
j
i
for(i=0;i<Nx;i++)
for(j=0;j<Ny;j++)
out[i*Ny+j]=
in[i*Ny+j];

 CUDAで2次元的に並列化してアクセスする場合
i = blockIdx.x*blockDim.x
+ threadIdx.x;
j = blockIdx.y*blockDim.y
+ threadIdx.y;
out[j*Nx+i]=in[j*Nx+i];
in[],out[]
Nx
Ny
j
i
for(i=0;i<Nx;i++)
for(j=0;j<Ny;j++)
out[i*Ny+j]=
in[i*Ny+j];
threadIdx.x
threadIdx.y
threadIdx.xのスレッド群（threadIdx.yが一定）
が連続なメモリアドレスにアクセス

#include<stdio.h>
#define Nx 4096
#define Ny 2048
#define Tx 16
#define Ty 16
__global__
+ threadIdx.x;
+ threadIdx.y;
in[j*Nx + i] = j;
out[j*Nx + i] = ‐1;
}
__global__
+ threadIdx.x;
+ threadIdx.y;
out[i*Ny + j] = in[j*Nx + i];
}
int main(){
int *in,*out;
transpose<<<Block, Thread>>>
(in,out);
return 0;
}
GPUプログラム
transpose.cu

実行時間
copy(目標値) 0.802 / 1.57
transpose 1.34

転置時のメモリアクセス
 読込はコアレスアクセス
 書込はストライドアクセス
 キャッシュはメモリアクセスの改善には利用できない
in[]
out[]
・・・・・・・・・・・・・・・・・・・・・
・・・・・・・・・・・・・・・・・・・・・
Ny*sizeof(int)バイトの
ストライドアクセス

転置時のメモリアクセス
 読込はコアレスアクセス
 書込は非コアレスアクセス
 キャッシュはメモリアクセスの改善には利用できない
in[] out[]
threadIdx.xの群が連続
なメモリアドレスにアクセス
Ny
Nx
Nx
Ny
threadIdx.yの群が連続
なメモリアドレスにアクセス
threadIdx.y
threadIdx.y
threadIdx.x
threadIdx.x

in[]
共有メモリによるメモリアクセスの改善
 共有メモリは制約が緩い
 一度グローバルメモリから共有メモリにコピー
 ここは元々コアレスアクセス
out[]
threadIdx.y
threadIdx.x
threadIdx.x
threadIdx.y

in[]
共有メモリによるメモリアクセスの改善
 共有メモリは制約が緩い
 共有メモリ内で転置
 共有メモリからグローバルメモリへコアレスアクセス
out[]
threadIdx.y
threadIdx.x
threadIdx.x
threadIdx.y

グローバルメモリから共有メモリへの書込
__shared__ int data[Tx][Ty]; //ブロック内のスレッドが使うサイズだけ宣言
int i = blockIdx.x*blockDim.x + threadIdx.x; //配列添字とスレッド番号の
int j = blockIdx.y*blockDim.y + threadIdx.y; //対応を計算
原点からのズレ
//グローバルメモリから共有メモリへコピー（コアレスアクセス）
data[threadIdx.x][threadIdx.y] = in[j*Nx + i];
__syncthreads(); //ブロック内の全スレッドがコピーを完了するのを待機
(0,0)
(0,1)
(0,2)
(0,3)
(1,0)
(1,1)
(1,2)
(1,3)
(2,0)
(2,1)
(2,2)
(2,3)
(3,0)
(3,1)
(2,3)
(3,3)
(0,0)
(1,0)
(2,0)
(3,0)
(0,1)
(1,1)
(2,1)
(3,1)
(0,2)
(1,2)
(2,2)
(3,2)
(0,3)
(1,3)
(2,3)
(3,3)
グローバルメモリから読み
込んだデータをそのまま共
有メモリへ書込み
blockIdx.x*blockDim.x=1*4
blockIdx.y*blockDim.y=0*4
threadIdx.x
threadIdx.y
threadIdx.x
threadIdx.y

共有メモリからグローバルメモリへの書込
i = blockIdx.y*blockDim.y + threadIdx.x;
j = blockIdx.x*blockDim.x + threadIdx.y;
原点からのズレ
配列out[]の横幅（コピー時の書き方out[j*Nx + i] = in[j*Nx + i];と同じ）
out[j*Ny + i] = data[threadIdx.y][threadIdx.x];
(0,0)(1,0)(2,0)(3,0)
(0,1)(1,1)(2,1)(3,1)
(0,2)(1,2)(2,2)(3,2)
(0,3)(1,3)(2,3)(3,3)
(0,0)
(1,0)
(2,0)
(3,0)
(0,1)
(1,1)
(2,1)
(3,1)
(0,2)
(1,2)
(2,2)
(3,2)
(0,3)
(1,3)
(2,3)
(3,3)
各スレッドが共有メモリへ
アクセスする位置を転置
blockIdx.y*blockDim.y=0*4
blockIdx.x*blockDim.x=1*4
Ny
threadIdx.x
threadIdx.y
threadIdx.y
threadIdx.x
threadIdx.x,
threadIdx.y が
参照する次元が
入れ替わっている

__global__ void transpose_shared(int *in, int *,out){
}
共有メモリを利用するカーネル
transpose_shared.cu

実行時間
1.4倍
高速化*
*高速化率=基準となる実行時間/高速化したカーネルによる実行時間
copy(目標値) 0.802 / 1.57
transpose 1.34
transpose_shared 0.977

2次元配列におけるバンクコンフリクト
（Tesla世代）
 転置の計算
 共有メモリにアクセス
する添字が入れ替わる
 読込か書込のどちらか
でバンクコンフリクトが
発生
124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
192
data[16][16]
・・・
Half Warp内でのスレッドID メモリアドレス
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
192
（Tesla世代）
 transpose_shared.
cuの場合
 読込のアクセス
 書込のアクセス
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
//16‐wayバンクコンフリクト
data[threadIdx.x][threadIdx.y]
・・・
バンク
コンフリクト
data[threadIdx.x][0]
data[threadIdx.y][threadIdx.x]

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
（Tesla世代）
cuの場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
バンク
コンフリクト
64 1280 192

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
192
（Tesla世代）
cuの場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
data[0][threadIdx.x]
//コンフリクトフリー

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
（Tesla世代）
cuの場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
64 1280 192

バンクコンフリクトの低減（Tesla世代）
 解消は非常に簡単
 配列を余分に確保してバ
ンクをずらす
 data[16][16]
 data[16__][16__]
210
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1 1
0 0
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
…
バンク番号

 解消は非常に簡単
 配列を余分に確保してバ
ンクをずらす
 data[16][16]
 data[16 ][16+1]
 配列を余分に確保するこ
とをパディング（詰め物）
するという
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
…
210
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2

1 2 30
 メモリパディングをした
場合
・・・
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
2
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・

場合
スレッドのアクセス要求 1 2 30
・・・
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
2
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・

場合
・・・
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
2
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
2
1
0
15
14
13
12
11
10
9
8
7
6
5
4
3
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・

（Fermi世代）
 バンクの数が32に増加
 配列要素数に応じてバンクが折りたたまれる
 配列の2次元の要素数とバンクの数が同じ場合
0
12
8
25
6
38
4
0 1 2 3
16
14
4
27
2
40
0
4 5 6 7
32
16
0
28
8
41
6
8 9 10 11
48
17
6
30
4
43
2
12 13 14 15
data[8][32]
…
data[0][32]
data[1][32]
data[2][32]
data[3][32]
64
19
2
32
0
44
8
16 17 18 19
80
20
8
33
6
46
4
20 21 22 23
96
22
4
35
2
48
0
24 25 26 27
11
2
24
0
35
8
49
6
28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
バンク番号

（Fermi世代）
 配列の2次元の要素数とバンクの数が異なる場合
…
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
0
12
8
64
19
2
16
14
4
80
20
8
32
16
0
96
22
4
48
17
6
11
2
24
0
data[0][16]
data[1][16]
data[2][16]
data[3][16]

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
…
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
data[2][16]
data[3][16]
バンク番号

2次元的なスレッドとWarpの対応
（Fermi世代）
 1ブロック内のスレッドはWarp単位で実行
 32個の連続したスレッド
 1ブロック内にスレッドが2次元的に配置されていても，ハー
ドウェア的には1次元的に配置
 ブロック内のスレッド番号とWarpの対応
 threadIdx.xの値が最初に変化（最も内側）
 threadIdx.xがカーネル起動時に設定された数字を超え
るとthreadIdx.yの値が変化
 スレッド数を(16,16,1)として起動した場合
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y
・・・0 1 2 3 4 5 6 7
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2 ・・・
Warp 0 Warp 1

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
コンフリクトフリー
…

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
 転置の計算
 共有メモリにアクセスする添字が入れ替わる
 読込か書込のどちらかでバンクコンフリクトが発生
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
 transpose_shared.cuの場合
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…
data[threadIdx.x][0] data[threadIdx.x][1]
バンク
コンフリクト
バンク
コンフリクト
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…
バンク
コンフリクト
バンク
コンフリクト
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…
data[0][threadIdx.x] data[1][threadIdx.x]
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
（Fermi世代）
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

バンクコンフリクトの低減（Fermi世代）
 配列を余分に確保してバンクをずらす
 data[16][16]
 data[16][16+1]
data[16][17]
0 16 32 48 64
追加分の配列要素
80 96 11
2
12
8
14
4
16
0
17
6
19
2
20
8
22
4
24
0
25
6
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
…
data[0][17]
data[1][17]
data[2][17]
data[3][17]

19 20 21 22 23 24 25 26 27 28 29 30 31 0 1
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
 配列を余分に確保してバンクをずらす
 data[16][16]
 data[16][16+1]
data[16][17]
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 2 3
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
…
data[0][17]
data[1][17]
data[2][17]
data[3][17]

19 20 21 22 23 24 25 26 27 28 29 30 31 0 11 2 3
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
 メモリパディングをした場合
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][17]
data[0][17]
data[1][17]
data[2][17]
data[3][17]
…
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
threadIdx.x
threadIdx.y
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1

19 20 21 22 23 24 25 26 27 28 29 30 31 0 11 2 3
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][17]
data[0][17]
data[1][17]
data[2][17]
data[3][17]
…
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
threadIdx.x
threadIdx.y
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1

19 20 21 22 23 24 25 26 27 28 29 30 31 0 11 2 3
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][17]
data[0][17]
data[1][17]
data[2][17]
data[3][17]
…
バンク
コンフリクト
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
threadIdx.x
threadIdx.y
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1

__global__ void transpose_reducebankconflict(int *in, int *,out){
__shared__ int data[Tx][Ty+1]; //バンクコンフリクトを回避
}
バンクコンフリクトを低減したカーネル
transpose_reducebankconflict.cu

実行時間
1.1倍
高速化*
copy(目標値) 0.802 / 1.57
transpose 1.34
transpose_reducebankconflict 0.926
*高速化率=基準となる実行時間/高速化したカーネルによる実行時間

 CUDAで2次元的に並列化してアク
セスする場合
 threadIdx.xのスレッド群（threadI
dx.yが一定）が連続なメモリアドレス
にアクセス
 C言語の多次元配列
 2次元目の要素が連続になるようメモ
リに確保
 transpose_shared.cuの共有メ
モリの使い方は不適切
in[],out[]
Nx
Ny
j
i
threadIdx.x
threadIdx.y
data[Tx][Ty]
Tx
Ty
j
i
threadIdx.x
threadIdx.y

 共有メモリの宣言の変更
 1次元目と2次元目を入れ替え
 data[Tx][Ty]
 data[Ty][Tx]
 配列参照
 1次元目の添字はthreadIdx.yを利用
 2次元目の添字はthreadIdx.xを利用
 threadIdx.xのスレッド群（threadIdx.
yが一定）が連続なメモリアドレスにアク
セス
data[Tx][Ty]
Tx
Ty
j
i
threadIdx.x
threadIdx.y
data[Ty][Tx]
Ty
Tx
i
j
threadIdx.y
threadIdx.x

}
共有メモリを利用するカーネル
transpose_shared.cu

__shared__ int data[Ty][Tx]; //ブロック内のスレッドが使うサイズだけ宣言
data[threadIdx.y][threadIdx.x] = in[j*Nx + i];
out[j*Ny + i] = data[threadIdx.x][threadIdx.y];
}
共有メモリの添字を交換したカーネル
transpose_shared_indexchange.cu

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
192
配列添字を入れ替えた場合の共有メモリへ
のアクセス（Tesla世代）
 配列添字を入れ替え
た場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
た場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
64 1280 192

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
64
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
128
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
0
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
192
た場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
バンク
コンフリクト

124
120
116
112
108
104
100
96
92
88
84
80
76
72
68
188
184
180
176
172
164
160
160
156
152
148
144
140
136
132
60
56
52
48
44
40
36
32
28
24
20
16
12
8
4
256
252
248
244
240
236
232
228
224
220
216
208
204
200
196
た場合
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
・・・
0
2
3
5
1
6
8
14
4
7
9
15
10
11
12
13
バンク番号
・・・
バンク
コンフリクト
64 1280 192

のアクセス（Fermi世代）
 配列添字を入れ替えた場合
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

…
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
…
バンク
コンフリクト
バンク
コンフリクト
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

…
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
data[16][16]
data[0][16]
data[1][16]
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15data[2][16]
data[3][16]
バンク
コンフリクト
バンク
コンフリクト
0
0
1
0
2
0
3
0
4
0
5
0
6
0
7
0
8
0
9
0
10
0
11
0
12
0
13
0
14
0
15
0
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
1
10
1
11
1
12
1
13
1
14
1
15
1
threadIdx.x
threadIdx.y

実行時間
copy(目標値) 0.802 / 1.57
transpose 1.34
transpose_shared_indexchange 0.939
有意に
高速化

__global__ void transpose_reducebankconflict(int *in, int *,out){
__shared__ int data[Ty][Tx+1]; //バンクコンフリクトを回避
data[threadIdx.y][threadIdx.x] = in[j*Nx + i];
out[j*Ny + i] = data[threadIdx.x][threadIdx.y];
}
共有メモリの添字を交換，パディングした
カーネル
transpose_reducebankconflict_indexchange.cu

実行時間
copy(目標値) 0.802 / 1.57
transpose 1.34
transpose_shared_indexchange 0.939
transpose_reducebankconflict
_indexchange 0.926
ほぼ同じ

付録書込と読込のアクセスの影響
 スレッド数(Tx×Ty=16×16)で配列サイズを変更
 読込と書込でコアレス・ストライドアクセスが変化
 書込がコアレスアクセスになる方が高速になる傾向
 GPUでは書込をキャッシュできないことが理由と思われる
カーネル
実行時間 [ms]
4096×2048 2048×1024 1024×512
copy(目標値)
(rw:コアレス/rw:ストライド)
0.802/1.57 0.202/0.389 0.055/0.103
transpose
(r:コアレス,w:ストライド)
1.39 0.348 0.089
simple_transpose
(r:ストライド,w:コアレス)
1.13 0.289 0.077

2015年度先端GPGPUシミュレーション工学特論　第4回　GPUのメモリ階層の詳細（共有メモリ）

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (19)

Similar to 2015年度先端GPGPUシミュレーション工学特論　第4回　GPUのメモリ階層の詳細（共有メモリ）

Similar to 2015年度先端GPGPUシミュレーション工学特論　第4回　GPUのメモリ階層の詳細（共有メモリ） (20)

More from 智啓出川

More from 智啓出川 (11)