GPU Computing with CUDA

Lecture 3 - Efficient Shared Memory Use

Christopher Cooper
Boston University
August, 2011
UTFSM, Valparaso, Chile
1

Outline of lecture
Recap of Lecture 2
Shared memory in detail
Tiling
Bank conflicts

Recap
Thread hierarchy
- Thread are grouped in thread blocks
- Threads of the same block are executed on the same SM at the same
time
Threads can communicate with shared memory
An SM can have up to 8 blocks at the same time

- Thread blocks are divided sequentially into warps of 32 threads each

- Threads of the same warp are scheduled together
- SM implements a zero-overhead warp scheduling
3

Recap
Memory hierarchy

Smart use of
memory hierarchy!
4

Recap
Programming model: Finite Difference case
- One node per thread
- Node indexing automatically groups into thread blocks!

Recap
Programming model: Finite Difference case
- One node per thread
- Node indexing automatically groups into thread blocks!
Thread = node

Thread block

Shared Memory
Small (48kB per SM)
Fast (~4 cycles): On-chip
Private to each block
- Allows thread communication

How can we use it?

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];
if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];
if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];

Loads
element i

if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];

Loads
element i

Loads
element i-1

if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];
if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i +1
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];
if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i +1
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];

Loads
element i+1

if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i +1
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];

Loads
element i+1

Loads
element i

if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Shared Memory - Making use of it

Looking at a 1D FDM example (similar to lab)

u
u
=c
t
x

n+1
ui

n
ui

ct n
n

(ui ui1 )
x

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc,int
BLOCKSIZE)
{
//Eachthreadwillloadoneelement
Thread i +1
inti=threadIdx.x+BLOCKSIZE*blockIdx.x;

if(i>=N){return;}
u_prev[i]=u[i];

Loads
element i+1

Loads
element i

if(i>0)
{u[i]=u_prev[i]c*dt/dx*(u_prev[i]u_prev[i1]);
}
}

Order N redundant loads!

Shared Memory - Making use of it

Idea: We could load only once to shared memory, and operate there

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];

if(I>=N){return;}
u_shared[i]=u[I];
__syncthreads();
if(I>0)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);}
}

Shared Memory - Making use of it

Idea: We could load only once to shared memory, and operate there

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];
Allocate shared array

if(I>=N){return;}
u_shared[i]=u[I];
__syncthreads();
if(I>0)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);}
}

Shared Memory - Making use of it

Idea: We could load only once to shared memory, and operate there

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];
Allocate shared array

if(I>=N){return;}
u_shared[i]=u[I];
Load to shared mem
__syncthreads();
if(I>0)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);}
}

Shared Memory - Making use of it

Idea: We could load only once to shared memory, and operate there

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];
Allocate shared array

if(I>=N){return;}
u_shared[i]=u[I];
Load to shared mem
__syncthreads();
if(I>0)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);}
}

Fetch shared mem

Shared Memory - Making use of it

Idea: We could load only once to shared memory, and operate there

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];
Allocate shared array

if(I>=N){return;}
u_shared[i]=u[I];
Load to shared mem
__syncthreads();
if(I>0)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);}
}

Fetch shared mem

Works if N <= Block size... What if not?

8

Shared Memory - Making use of it

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];

if(I>=N){return;}
u_prev[I]=u[I];
u_shared[i]=u[I];
__syncthreads();
if(i>0&&i<BLOCKSIZE1)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);
}
else
{u[I]=u_prev[I]c*dt/dx*(u_prev[I]u_prev[I1]);
}

Shared Memory - Making use of it

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];

if(I>=N){return;}
u_prev[I]=u[I];
u_shared[i]=u[I];
__syncthreads();
if(i>0&&i<BLOCKSIZE1)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);
}
else
{u[I]=u_prev[I]c*dt/dx*(u_prev[I]u_prev[I1]);
}

Shared Memory - Making use of it

__global__voidupdate(float*u,float*u_prev,intN,floatdx,floatdt,floatc)
{
//Eachthreadwillloadoneelement
inti=threadIdx.x;
intI=threadIdx.x+BLOCKSIZE*blockIdx.x;
__shared__floatu_shared[BLOCKSIZE];

if(I>=N){return;}
u_prev[I]=u[I];
u_shared[i]=u[I];
__syncthreads();
if(i>0&&i<BLOCKSIZE1)
{u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);
}
else
{u[I]=u_prev[I]c*dt/dx*(u_prev[I]u_prev[I1]);
}

Reduced loads from 2*N to N+2*N/BLOCKSIZE

9

Using shared memory as cache

Looking at the 2D heat diffusion problem from lab 2
2

u
u
= 2
t
x
Explicit scheme
un+1
i,j

uni,j

k n
+ 2 (ui,j+1 + uni,j1 + uni+1,j + uni1,j 4uni,j )
h
T=0

T = 200

T=0

T = 200

10

Shared Memory Implementation - Mapping Problem

Using row major flattened array
inti=threadIdx.x;
intj=threadIdx.y;
intI=blockIdx.y*BSZ*N+blockIdx.x*BSZ+j*N+i;

Nx*(Ny-1)

I increasing

Nx*Ny-1

I increasing

Nx-1
11

Shared Memory Implementation - Global Memory

This implementation has redundant loads to global memory

slow

__global__voidupdate(float*u,float*u_prev,intN,floath,floatdt,float
alpha,intBSZ)
{
//Settingupindices
inti=threadIdx.x;
intj=threadIdx.y;
intI=blockIdx.y*BSZ*N+blockIdx.x*BSZ+j*N+i;

if(I>=N*N){return;}
u_prev[I]=u[I];

//ifnotboundarydo
if((I>N)&&(I<N*N1N)&&(I%N!=0)&&(I%N!=N1))
{u[I]=u_prev[I]+alpha*dt/(h*h)*(u_prev[I+1]+u_prev[I1]+
u_prev[I+N]+u_prev[IN]4*u_prev[I]);
}
}
12

Shared Memory Implementation - Solution 1

Recast solution given earlier
- Load to shared memory
- Use shared memory if not on boundary of a block

Global memory

- Use global memory otherwise

Advantage
- Easy to implement

Disadvantage
- Branching statement
- Still have some redundant loads

Shared memory

13

Shared Memory Implementation - Solution 1

__global__voidupdate(float*u,float*u_prev,intN,floath,floatdt,floatalpha)
{
//Settingupindices
inti=threadIdx.x;
intj=threadIdx.y;
intI=blockIdx.y*BSZ*N+blockIdx.x*BSZ+j*N+i;
if(I>=N*N){return;}
__shared__floatu_prev_sh[BSZ][BSZ];
u_prev_sh[i][j]=u[I];
u_prev[I]=u[I];
__syncthreads();
boolbound_check=((I>N)&&(I<N*N1N)&&(I%N!=0)&&(I%N!=N1));
boolblock_check=((i>0)&&(i<BSZ1)&&(j>0)&&(j<BSZ1));

//ifnotonblockboundarydo
if(block_check)
{u[I]=u_prev_sh[i][j]+alpha*dt/h/h*(u_prev_sh[i+1][j]+u_prev_sh[i1]
[j]+u_prev_sh[i][j+1]+u_prev_sh[i][j1]4*u_prev_sh[i][j]);
}
//ifnotonboundary
elseif(bound_check)
{u[I]=u_prev[I]+alpha*dt/(h*h)*(u_prev[I+1]+u_prev[I1]+u_prev[I+N]
+u_prev[IN]4*u_prev[I]);
}
14
}

Shared Memory Implementation - Solution 2

We want to avoid the reads from global memory
- Lets use halo nodes to compute block edges

Images: Mark Giles, Oxford, UK

15

Shared Memory Implementation - Solution 2

Change indexing so to
jump in steps of BSZ-2
instead of BSZ

BSZ

BSZ -2

Operate on internal
nodes

BSZ

Load data to shared

memory

BSZ -2

Well need Nx/(BSZ-2)

blocks per dimension,
instead of BSZ/N

16

Shared Memory Implementation - Solution 2

__global__voidupdate(float*u,float*u_prev,intN,floath,floatdt,floatalpha)
{
//Settingupindices
inti=threadIdx.x,j=threadIdx.y,bx=blockIdx.x,by=blockIdx.y;
intI=(BSZ2)*bx+i,J=(BSZ2)*by+j;
intIndex=I+J*N;

if(I>=N||J>=N){return;}
__shared__floatu_prev_sh[BSZ][BSZ];
u_prev_sh[i][j]=u[Index];
__syncthreads();
boolbound_check=((I!=0)&&(I<N1)&&(J!=0)&&(J<N1));
boolblock_check=((i!=0)&&(i<BSZ1)&&(j!=0)&&(j<BSZ1));
if(bound_check&&block_check)
{u[Index]=u_prev_sh[i][j]+alpha*dt/h/h*(u_prev_sh[i+1][j]+
u_prev_sh[i1][j]+u_prev_sh[i][j+1]+u_prev_sh[i][j1]4*u_prev_sh[i][j]);
}
}
17

Shared Memory Implementation - Solution 2

Weve eliminated all redundant global memory accesses!
But...
- Theres still a heavy amount of branching
GPUs are not great at branching... well look into that later today

- All threads read, but only some operate

Were underutilizing the device!
If we have 16x16 = 256 threads, all read, but only 14x14 = 196
operate, and were using only ~75% of the device. In 3D this number
drops to ~40%!
18

Shared Memory Implementation - Solution 3

We need to go further...

BSZ+2

BSZ

- Load in two stages

BSZ+2

- To not underutilize the

device, we need to
load more data than
threads

BSZ

- Operate on [i+1][j+1]
threads

19

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared
__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared
__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared

64th

__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared

64th

__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared
__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared
__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

20

Shared Memory Implementation - Solution 3

Loading in 2 steps
- Use the 64 available threads to load the
64 first values to shared
__shared__floatu_prev_sh[BSZ+2][BSZ+2];
intii=j*BSZ+i,//Flattenthreadindexing
I=ii%(BSZ+2),//xdirectionindexincludinghalo
J=ii/(BSZ+2);//ydirectionindexincludinghalo
intI_n=I_0+J*N+I;//Generalindex
u_prev_sh[I][J]=u[I_n];

- Load the remaining values

intii2=BSZ*BSZ+j*BSZ+i;
intI2=ii2%(BSZ+2);
intJ2=ii2/(BSZ+2);

I0

8x8 threads
10x10 loads

intI_n2=I_0+J2*N+I2;//Generalindex
if((I2<(BSZ+2))&&(J2<(BSZ+2))&&(ii2<N*N))
u_prev_sh[I2][J2]=u[I_n2];

Some threads wont load

20

Shared Memory Implementation - Solution 3

Compute on interior points: threads [i+1][j+1]

Index
intIndex=by*BSZ*N+bx*BSZ+(j+1)*N+i+1;

u[Index]=u_prev_sh[i+1][j+1]+alpha*dt/h/h*(u_prev_sh[i+2][j+1]+u_prev_sh[i][j+1]+
u_prev_sh[i+1][j+2]+u_prev_sh[i+1][j]4*u_prev_sh[i+1][j+1]);
21

SM Implementation
The technique described is called tiling
- Tiling means loading data to shared memory in tiles
- Useful when shared memory is used as cache
- Also used when all data is to large to fit in shared memory and you
load it in smaller chunks

We will implement this in tomorrows lab!

22

Shared Memory - Bank conflicts

Shared memory arrays are subdivided into smaller subarrays called
banks
Shared memory has 32 (16) banks in 2.X (1.X). Successive 32-bit
words are assigned to successive banks
Different banks can be accessed simultaneously
If two or more addresses of a memory request are in the same bank,
the access is serialized
- Bank conflicts exist only within a warp (half warp for 1.X)

In 2.X there is no bank conflict if the memory request is for the same
32-bit word. This is not valid in 1.X.
23

Shared Memory - Bank conflicts

24

Shared Memory
__syncthreads()
- Barrier that waits for all threads of the block before continuing
- Need to make sure all data is loaded to shared before access
- Avoids race conditions
- Serializes the code: dont over use!
u_shared[i]=u[I];
__syncthreads();
if(i>0&&i<BLOCKSIZE1)
u[I]=u_shared[i]c*dt/dx*(u_shared[i]u_shared[i1]);

25

Race condition
When two or more threads want to access and operate on a memory
location without syncronization
Example: we have the value 3 stored in global memory and two
threads want to add one to that value.
- Possibility 1:
Thread 1 reads the value 3 adds 1 and writes 4 back to memory
Thread 2 reads the value 4 and writes 5 back to memory
- Possibility 2:
Thread 1 reads the value 3
Thread 2 reads the value 3
Both threads operate on 3 and write back the value 4 to memory

Solutions:
- __syncthreads() or atomic operations

26

Race condition
When two or more threads want to access and operate on a memory
location without syncronization
Example: we have the value 3 stored in global memory and two
threads want to add one to that value.
- Possibility 1:
Thread 1 reads the value 3 adds 1 and writes 4 back to memory
Thread 2 reads the value 4 and writes 5 back to memory
- Possibility 2:
Thread 1 reads the value 3
Thread 2 reads the value 3
Both threads operate on 3 and write back the value 4 to memory

Solutions:
- __syncthreads() or atomic operations

26

Race condition
When two or more threads want to access and operate on a memory
location without syncronization
Example: we have the value 3 stored in global memory and two
threads want to add one to that value.
- Possibility 1:
Thread 1 reads the value 3 adds 1 and writes 4 back to memory
Thread 2 reads the value 4 and writes 5 back to memory
- Possibility 2:
Thread 1 reads the value 3
Thread 2 reads the value 3
Both threads operate on 3 and write back the value 4 to memory

Solutions:
- __syncthreads() or atomic operations

26

Atomic operations
Atomic operations deal with race conditions
- It guarantees that while the operation is being executed, that
location in memory os not accessed
- Still we cant rely on any ordering of thread execution!
- Types
atomicAdd
atomicSub
atomicExch
atomicMin
atomicMax
etc...

27

Atomic operations

__global__update(int*values,int*who)
{
inti=threadIdx.x+blockDim.x*blockIdx.x;
intI=who[i];
atomicAdd(&values[I],1);
}

David Tarjan - NVIDIA

28

Atomic operations
Useful if you have a sparse access pattern
Atomic operations are slower than normal function
They can serialize your execution if many threads want to access the
same memory location
- Think about parallelizing your data, not only execution
- Use hierarchy of atomic operations to avoid this

Prefer __syncthreads() if you can use it instead

- If you have a regular access pattern

29