Presentation is loading. Please wait.

Presentation is loading. Please wait.

Introduction to CUDA (2 of 2) Patrick Cozzi University of Pennsylvania CIS 565 - Fall 2012.

Similar presentations


Presentation on theme: "Introduction to CUDA (2 of 2) Patrick Cozzi University of Pennsylvania CIS 565 - Fall 2012."— Presentation transcript:

1 Introduction to CUDA (2 of 2) Patrick Cozzi University of Pennsylvania CIS Fall 2012

2 Announcements Open pull request for Project 0 Project 1 released. Due Sunday 09/30  Not due Tuesday, 09/25  Code on GitHub  grade to Karl 2

3 Agenda Built-ins and functions Synchronizing threads Scheduling threads Memory model Matrix multiply revisited Atomic functions 3

4 Functional Declarations Executed on the:Only callable from the: __global__ void KernelFunc() devicehost __device__ float DeviceFunc() device __host__ float HostFunc() host See Appendix B.1 in the NVIDIA CUDA C Programming Guide for more details 4

5 Functional Declarations __global__ Must return void __device__ Inlined by default See Appendix B.1 in the NVIDIA CUDA C Programming Guide for more details 5

6 Functional Declarations What do these do? __global__ __host__ void func() __device__ __host__ void func() 6

7 Functional Declarations What do these do? __global__ __host__ void func() __device__ __host__ void func() Code from 7

8 Functional Declarations Global and device functions No recursion (except Fermi) No static variables No malloc() Careful with function calls through pointers We’ll see similar constraints in GLSL 8

9 Vector Types char[1–4], uchar[1–4] short[1–4], ushort[1–4] int[1–4], uint[1–4] long[1–4], ulong[1–4] longlong[1–4], ulonglong[1–4] float[1–4] double1, double2 9

10 Vector Types Available in host and device code Construct with make_ int2 i2 = make_int2(1, 2); float4 f4 = make_float4( 1.0f, 2.0f, 3.0f, 4.0f); 10

11 Vector Types Access with. x,.y,.z, and.w int2 i2 = make_int2(1, 2); int x = i2.x; int y = i2.y; No. r,.g,.b,.a, etc. like GLSL 11

12 Math Functions Double and float overloads  No vector overloads On the host, functions use the C runtime implementation if available See Appendix C in the NVIDIA CUDA C Programming Guide for a complete list of math functions 12

13 Math Functions Partial list:  sqrt, rsqrt  exp, log  sin, cos, tan, sincos  asin, acos, atan2  trunc, ceil, floor See Appendix C in the NVIDIA CUDA C Programming Guide for a complete list of math functions 13

14 Math Functions Intrinsic function  Device only  Faster, but less accurate  Prefixed with __  __exp, __log, __sin, __pow, … See Appendix C in the NVIDIA CUDA C Programming Guide for a complete list of math functions 14

15 Review: Thread Hierarchies Image from: 15

16 Review: Thread Hierarchies int threadID = blockIdx.x * blockDim.x + threadIdx.x; float x = input[threadID]; float y = func(x); output[threadID] = y; 16

17 Review: Thread Hierarchies int threadID = blockIdx.x * blockDim.x + threadIdx.x; float x = input[threadID]; float y = func(x); output[threadID] = y; Use grid and block position to compute a thread id 17

18 Review: Thread Hierarchies int threadID = blockIdx.x * blockDim.x + threadIdx.x; float x = input[threadID]; float y = func(x); output[threadID] = y; Use thread id to read from input 18

19 Review: Thread Hierarchies int threadID = blockIdx.x * blockDim.x + threadIdx.x; float x = input[threadID]; float y = func(x); output[threadID] = y; Run function on input: data-parallel! 19

20 Review: Thread Hierarchies int threadID = blockIdx.x * blockDim.x + threadIdx.x; float x = input[threadID]; float y = func(x); output[threadID] = y; Use thread id to output result 20

21 Thread Synchronization Threads in a block can synchronize  call __syncthreads to create a barrier  A thread waits at this call until all threads in the block reach it, then all threads continue Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i + 1]); 21

22 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 0 Thread 0Thread 1 Thread 2 Thread 3 22

23 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 1 Thread 0Thread 1 Thread 2 Thread 3 23

24 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 1 Thread 0Thread 1 Thread 2 Thread 3 Threads 0 and 1 are blocked at barrier 24

25 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 2 Thread 0Thread 1 Thread 2 Thread 3 25

26 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 3 Thread 0Thread 1 Thread 2 Thread 3 26

27 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 3 Thread 0Thread 1 Thread 2 Thread 3 All threads in block have reached barrier, any thread can continue 27

28 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 4 Thread 0Thread 1 Thread 2 Thread 3 28

29 Thread Synchronization Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Mds[i] = Md[j]; __syncthreads(); func(Mds[i], Mds[i+1]); Time: 5 Thread 0Thread 1 Thread 2 Thread 3 29

30 Thread Synchronization Why is it important that execution time be similar among threads? Why does it only synchronize within a block? 30

31 Thread Synchronization Image from 31

32 Thread Synchronization Can __syncthreads() cause a thread to hang? 32

33 Thread Synchronization if (someFunc()) { __syncthreads(); } //... 33

34 Thread Synchronization if (someFunc()) { __syncthreads(); } else { __syncthreads(); } 34

35 Scheduling Threads Slide from David Luebke: 35

36 Scheduling Threads 36

37 Scheduling Threads Streaming Processing (SP) 37

38 Scheduling Threads Streaming Multi-Processor (SM) 38

39 Scheduling Threads Look familiar? 39

40 Scheduling Threads Slide from David Luebke: G80 16 SMs Each with 8 SPs  128 total SPs Each SM hosts up to 768 threads Up to 12,288 threads in flight 40

41 Scheduling Threads Slide from David Luebke: GT SMs Each with 8 SPs  240 total SPs Each SM hosts up to  8 blocks, or  1024 threads In flight, up to  240 blocks, or  30,720 threads 41

42 Scheduling Threads Warp – threads from a block  G80 / GT200 – 32 threads  Run on the same SM  Unit of thread scheduling  Consecutive threadIdx values  An implementation detail – in theory warpSize 42

43 Scheduling Threads Image from: Warps for three blocks scheduled on the same SM. 43

44 Image from: Scheduling Threads Remember this: 44

45 Scheduling Threads Slide from: 45

46 Scheduling Threads What happens if branches in a warp diverge? 46

47 Image from: Scheduling Threads Remember this: 47

48 Scheduling Threads If 3 blocks are assigned to an SM and each block has 256 threads, how many warps are there? A SM on GT200 can host up to 1024 threads, how many warps is that? 48

49 Scheduling Threads 32 threads per warp but 8 SPs per SM. What gives? 49

50 Scheduling Threads 32 threads per warp but 8 SPs per SM. What gives? When an SM schedules a warp:  Its instruction is ready  8 threads enter the SPs on the 1 st cycle  8 more on the 2 nd, 3 rd, and 4 th cycles  Therefore, 4 cycles are required to dispatch a warp 50

51 Scheduling Threads Question  A kernel has 1 global memory read ( 200 cycles) 4 non-dependent multiples/adds  How many warps are required to hide the memory latency? 51

52 Scheduling Threads Solution  Each warp has 4 multiples/adds 16 cycles  We need to cover 200 cycles 200 / 16 = 12.5 ceil(12.5) = 13  13 warps are required 52

53 Memory Model Image from: Recall: 53

54 Memory Model Registers  Per thread  Fast, on-chip, read/write access  Increasing the number of registers used by a kernel has what affect? 54

55 Memory Model Registers - G80  Per SM Up to 768 threads 8K registers  How many registers per thread? 55

56 Memory Model Registers - G80  8K / 768 = 10 registers per thread  Exceeding limit reduces threads by the block  Example: Each thread uses 11 registers, and each block has 256 threads How many threads can a SM host? How many warps can a SM host? What does having less warps mean? 56

57 Memory Model Local Memory  Stored in global memory Copy per thread  Used for automatic arrays Unless all accessed with only constant indices 57

58 Memory Model Shared Memory  Per block  Fast, on-chip, read/write access  Full speed random access 58

59 Memory Model Shared Memory – G80  Per SM Up to 8 blocks 16 KB  How many KB per block 59

60 Memory Model Shared Memory – G80  16 KB / 8 = 2 KB per block  Example If each block uses 5 KB, how many blocks can a SM host? 60

61 Memory Model Global Memory  Long latency (100s cycles)  Off-chip, read/write access  Random access causes performance hit  Host can read/write  GT GB/s Up to 4 GB  G80 – 86.4 GB/s 61

62 Memory Model Constant Memory  Short latency, high bandwidth, read only access when all threads access the same location  Stored in global memory but cached  Host can read/write  Up to 64 KB 62

63 Memory Model Variable DeclarationMemoryScopeLifetime Automatic variables other than arrays registerthreadkernel Automatic array variables localthreadkernel __shared__ int sharedVar; sharedblockkernel __device__ int globalVar; globalgridapplication __constant__ int constantVar; constantgridapplication See Appendix B.2 in the NVIDIA CUDA C Programming Guide for more details 63

64 Memory Model Global and constant variables  Host can access with cudaGetSymbolAddress() cudaGetSymbolSize() cudaMemcpyToSymbol() cudaMemcpyFromSymbol()  Constants must be declared outside of a function body 64

65 Let’s revisit matrix multiple 65

66 Matrix Multiply: CPU Implementation Code from: void MatrixMulOnHost(float* M, float* N, float* P, int width)‏ { for (int i = 0; i < width; ++i)‏ for (int j = 0; j < width; ++j) { float sum = 0; for (int k = 0; k < width; ++k) { float a = M[i * width + k]; float b = N[k * width + j]; sum += a * b; } P[i * width + j] = sum; } 66

67 Matrix Multiply: CUDA Kernel Code from: Accessing a matrix, so using a 2D block 67

68 Matrix Multiply: CUDA Kernel Code from: Each kernel computes one output 68

69 Matrix Multiply: CUDA Kernel Code from: Where did the two outer for loops in the CPU implementation go? 69

70 Matrix Multiply: CUDA Kernel Code from: No locks or synchronization, why? 70

71 Matrix Multiply Problems  Limited matrix size Only uses one block G80 and GT200 – up to 512 threads per block  Lots of global memory access 71

72 Matrix Multiply Image from Remove size limitation  Break Pd matrix into tiles  Assign each tile to a block  Use threadIdx and blockIdx for indexing 72

73 Matrix Multiply Image from Example  Matrix: 4x4  TILE_WIDTH = 2  Block size: 2x2 73

74 Matrix Multiply Pd 1,0 Md 2,0 Md 1,1 Md 1,0 Md 0,0 Md 0,1 Md 3,0 Md 2,1 Pd 0,0 Md 3,1 Pd 0,1 Pd 2,0 Pd 3,0 Nd 0,3 Nd 1,3 Nd 1,2 Nd 1,1 Nd 1,0 Nd 0,0 Nd 0,1 Nd 0,2 Pd 1,1 Pd 0,2 Pd 2,2 Pd 3,2 Pd 1,2 Pd 3,1 Pd 2,1 Pd 0,3 Pd 2,3 Pd 3,3 Pd 1,3 Image from Example  Matrix: 4x4  TILE_WIDTH = 2  Block size: 2x2 74

75 Matrix Multiply __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { int Row = blockIdx.y * blockDim.y + threadIdx.y; int Col = blockIdx.x * blockDim.x + threadIdx.x; float Pvalue = 0; for (int k = 0; k < Width; ++k) Pvalue += Md[Row * Width + k] * Nd[k * Width + Col]; Pd[Row * Width + Col] = Pvalue; } Code from 75

76 Matrix Multiply __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { int Row = blockIdx.y * blockDim.y + threadIdx.y; int Col = blockIdx.x * blockDim.x + threadIdx.x; float Pvalue = 0; for (int k = 0; k < Width; ++k) Pvalue += Md[Row * Width + k] * Nd[k * Width + Col]; Pd[Row * Width + Col] = Pvalue; } Code from Calculate the row index of the Pd element and M 76

77 Matrix Multiply __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { int Row = blockIdx.y * blockDim.y + threadIdx.y; int Col = blockIdx.x * blockDim.x + threadIdx.x; float Pvalue = 0; for (int k = 0; k < Width; ++k) Pvalue += Md[Row * Width + k] * Nd[k * Width + Col]; Pd[Row * Width + Col] = Pvalue; } Code from Calculate the column index of Pd and N 77

78 Matrix Multiply __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { int Row = blockIdx.y * blockDim.y + threadIdx.y; int Col = blockIdx.x * blockDim.x + threadIdx.x; float Pvalue = 0; for (int k = 0; k < Width; ++k) Pvalue += Md[Row * Width + k] * Nd[k * Width + Col]; Pd[Row * Width + Col] = Pvalue; } Code from Each thread computes one element of the block sub-matrix 78

79 Matrix Multiply dim3 dimGrid(Width / TILE_WIDTH, Height / TILE_WIDTH); dim3 dimBlock(TILE_WIDTH, TILE_WIDTH); MatrixMulKernel >>( Md, Nd, Pd, TILE_WIDTH); Invoke kernel: 79

80 What about global memory access? 80

81 Matrix Multiply Limited by global memory bandwidth  G80 peak GFLOPS:  Require 1386 GB/s to achieve this  G80 memory bandwidth: 86.4 GB/s Limits code to 21.6 GFLOPS In practice, code runs at 15 GFLOPS  Must drastically reduce global memory access 81

82 Matrix Multiply Image from 82 M N P WIDTH ty tx Each input element is read by Width threads Use shared memory to reduce global memory bandwidth

83 Matrix Multiply Image from Break kernel into phases  Each phase accumlates Pd using a subset of Md and Nd  Each phase has good data locality Md Nd Pd Pd sub TILE_WIDTH WIDTH TILE_WIDTH bx tx 01 TILE_WIDTH by ty TILE_WIDTH TILE_WIDTH TILE_WIDTHE WIDTH 83

84 Matrix Multiply Image from Each thread  loads one element of Md and Nd in the tile into shared memory 84 Md Nd Pd Pd sub TILE_WIDTH WIDTH TILE_WIDTH bx tx 01 TILE_WIDTH by ty TILE_WIDTH TILE_WIDTH TILE_WIDTHE WIDTH m kbx by k m

85 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } 85

86 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Shared memory for a subset of Md and Nd 86

87 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Width/TILE_WIDTH Number of phases m Index for current phase 87

88 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Bring one element each from Md and Nd into shared memory 88

89 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Wait for every thread in the block, i.e., wait for the tile to be in shared memory 89

90 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Accumulate subset of dot product 90

91 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Why? 91

92 Code from __global__ void MatrixMulKernel( float* Md, float* Nd, float* Pd, int Width) { __shared__ float Mds[TILE_WIDTH][TILE_WIDTH]; __shared__ float Nds[TILE_WIDTH][TILE_WIDTH]; int bx = blockIdx.x; int by = blockIdx.y; int tx = threadIdx.x; int ty = threadIdx.y; int Row = by * TILE_WIDTH + ty; int Col = bx * TILE_WIDTH + tx; float Pvalue = 0; for (int m = 0; m < Width/TILE_WIDTH; ++m) { Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; __syncthreads(); for (int k = 0; k < TILE_WIDTH; ++k) Pvalue += Mds[ty][k] * Nds[k][tx]; __synchthreads(); } Pd[Row*Width+Col] = Pvalue; } Write final answer to global memory 92

93 Matrix Multiply How do you pick TILE_WIDTH ?  How can it be too large? 93

94 Matrix Multiply How do you pick TILE_WIDTH ?  How can it be too large? By exceeding the maximum number of threads/block  G80 and GT200 – 512  Fermi –

95 Matrix Multiply How do you pick TILE_WIDTH ?  How can it be too large? By exceeding the maximum number of threads/block  G80 and GT200 – 512  Fermi – 1024 By exceeding the shared memory limitations  G80: 16KB per SM and up to 8 blocks per SM  2 KB per block  1 KB for Nds and 1 KB for Mds (16 * 16 * 4)  TILE_WIDTH = 16  A larger TILE_WIDTH will result in less blocks 95

96 Matrix Multiply Shared memory tiling benefits  Reduces global memory access by a factor of TILE_WIDTH 16x16 tiles reduces by a factor of 16  G80 Now global memory supports GFLOPS Close to maximum of GFLOPS 96

97 First-order Size Considerations in G80 Each thread block should have many threads  TILE_WIDTH of 16 gives 16*16 = 256 threads There should be many thread blocks  A 1024*1024 Pd gives 64*64 = 4K Thread Blocks Each thread block perform 2*256 = 512 float loads from global memory for 256 * (2*16) = 8K mul/add operations.  Memory bandwidth no longer a limiting factor Slide from 97

98 Atomic Functions __device__ unsigned int count = 0; //... ++count; What is the value of count if 8 threads execute ++count ? 98

99 Atomic Functions Read-modify-write atomic operation  Guaranteed no interference from other threads  No guarantee on order Shared or global memory Requires compute capability 1.1 (> G80) See G.1 in the NVIDIA CUDA C Programming Guide for full compute capability requirements 99

100 Atomic Functions __device__ unsigned int count = 0; //... // atomic ++count atomicAdd(&count, 1); What is the value of count if 8 threads execute atomicAdd below? 100

101 Atomic Functions How do you implement atomicAdd ? __device__ int atomicAdd( int *address, int val); 101

102 Atomic Functions How do you implement atomicAdd ? __device__ int atomicAdd( int *address, int val) { // Made up keyword: __lock (address) { *address += val; } 102

103 Atomic Functions How do you implement atomicAdd without locking? 103

104 Atomic Functions How do you implement atomicAdd without locking? What if you were given an atomic compare and swap? int atomicCAS(int *address, int compare, int val); 104

105 Atomic Functions atomicCAS pseudo implementation int atomicCAS(int *address, int compare, int val) { // Made up keyword __lock(address) { int old = *address; *address = (old == compare) ? val : old; return old; } 105

106 Atomic Functions atomicCAS pseudo implementation int atomicCAS(int *address, int compare, int val) { // Made up keyword __lock(address) { int old = *address; *address = (old == compare) ? val : old; return old; } 106

107 Atomic Functions atomicCAS pseudo implementation int atomicCAS(int *address, int compare, int val) { // Made up keyword __lock(address) { int old = *address; *address = (old == compare) ? val : old; return old; } 107

108 Atomic Functions Example: *addr = 1; atomicCAS(addr, 1, 2); atomicCAS(addr, 1, 3); atomicCAS(addr, 2, 3); 108

109 Atomic Functions Example: *addr = 1; atomicCAS(addr, 1, 2); atomicCAS(addr, 1, 3); atomicCAS(addr, 2, 3); // returns 1 // *addr = 2 109

110 Atomic Functions Example: *addr = 1; atomicCAS(addr, 1, 2); atomicCAS(addr, 1, 3); atomicCAS(addr, 2, 3); // returns 2 // *addr = 2 110

111 Atomic Functions Example: *addr = 1; atomicCAS(addr, 1, 2); atomicCAS(addr, 1, 3); atomicCAS(addr, 2, 3); // returns 2 // *addr = 3 111

112 Atomic Functions Again, how do you implement atomicAdd given atomicCAS ? __device__ int atomicAdd( int *address, int val); 112

113 Atomic Functions __device__ int atomicAdd(int *address, int val) { int old = *address, assumed; do { assumed = old; old = atomicCAS(address, assumed, val + assumed); } while (assumed != old); return old; } 113

114 Atomic Functions __device__ int atomicAdd(int *address, int val) { int old = *address, assumed; do { assumed = old; old = atomicCAS(address, assumed, val + assumed); } while (assumed != old); return old; } Read original value at *address. 114

115 Atomic Functions __device__ int atomicAdd(int *address, int val) { int old = *address, assumed; do { assumed = old; old = atomicCAS(address, assumed, val + assumed); } while (assumed != old); return old; } If the value at *address didn’t change, increment it. 115

116 Atomic Functions __device__ int atomicAdd(int *address, int val) { int old = *address, assumed; do { assumed = old; old = atomicCAS(address, assumed, assumed + val); } while (assumed != old); return old; } Otherwise, loop until atomicCAS succeeds. The value of *address after this function returns is not necessarily the original value of *address + val, why? 116

117 Atomic Functions Lots of atomics: // Arithmetic // Bitwise atomicAdd() atomicAnd() atomicSub() atomicOr() atomicExch() atomicXor() atomicMin() atomicMax() atomicAdd() atomicDec() atomicCAS() See B.10 in the NVIDIA CUDA C Programming Guide 117

118 Atomic Functions How can threads from different blocks work together? Use atomics sparingly. Why? 118


Download ppt "Introduction to CUDA (2 of 2) Patrick Cozzi University of Pennsylvania CIS 565 - Fall 2012."

Similar presentations


Ads by Google