Objective

The objective of this problem is to implement a tiled image convolution using both shared

and constant memory. We will have a constant $5$x$5$ convolution mask, but will have

arbitrarily sized image. We will also keep the output tile size at $16$x$16.$

To use the constant memory for the convolution mask, you should first transfer the mask

data to the global memory of the device $($using cudaMalloc$()$ and cudaMemcpy$()).$

Then $($given that the pointer to the device array for the mask is named M$)$ the signature of

your kernel function should include const float $*\_\_$restrict$\_\_$ M as one

of the parameters as indicated in the class notes. This informs the compiler that the

contents of the mask array are constants and allow the SM hardware to aggressively cache

the mask data at runtime.

Convolution is used in many fields, such as image processing for image filtering. A standard

image convolution formula for a $5$x$5$ convolution mask $($filter$)$ M with an Image I is:

$,,,,$

$$

$$

$$

$$

$,$

where $,,$ is the output pixel at position i$,$j in channel c$,,,$ is the input pixel at

i$,$j in channel c $($the number of channels will always be $3$ for this problem corresponding

to the RGB values$),$ and $,$ is the mask at position x$,$y$.$

Input Data

The input is an interleaved image of height X width X channels. By interleaved, we

mean that the element I$[$y$][$x$]$ contains three values representing the RGB channels. This

means that to index a particular element's value, you will have to do something like:

index $=($yIndex$*$width $+$ xIndex$)*$channels $+$ channelIndex;

For this problem, the channelIndex is $0$ for R$,1$ for G$,$ and $2$ for B$.$ So$,$ to access the G

value of I$[$y$][$x$],$ you should use the linearized expression

I$[($yIndex$*$width$+$xIndex$)*$channels $+1].$

As mentioned above, the value of channels is always set to $3.$

Pseudo Code and Approach

A sequential pseudo code would look something like this:

maskWidth :$=5$

maskRadius :$=$ maskWidth$/2$ # this is integer division, so the result is $2$

for i from $0$ to height do

for j from $0$ to width do

for k from $0$ to channels

accum :$=0$

for y from $$maskRadius to maskRadius do

for x from $$maskRadius to maskRadius do

xOffset :$=$ j $+$ x

yOffset :$=$ i $+$ y

if xOffset $>=0$ && xOffset $<$ width &&

yOffset $>=0$ && yOffset $<$ height then

imagePixel :$=$ I$[($yOffset $*$ width $+$ xOffset$)*$ channels $+$ k$]$

maskValue :$=$ K$[($y$+$maskRadius$)*$maskWidth$+$x$+$maskRadius$]$

accum $+=$ imagePixel $*$ maskValue

end

end

end

# pixels are in the range of $0$ to $1$

P$[($i $*$ width $+$ j$)*$channels $+$ k$]=$ clamp$($accum$,0,1)$

end

end

end

where clamp is defined as

def clamp$($x$,$ lower, upper$)$

return min$($max$($x$,$ lower$),$ upper$)$

end

In this problem, you are expected to write a kernel that performs the same operation that is

performed by the above sequential code $($e$.$g$.,$ you also need to clamp your output values$).$

To implement your kernel you can either make your block size as big as the output tile

$($Design $1)$ or make your block size as big as the input tile $($Design $2).$

Coding

Edit the code in the code tab to perform the following:

$$ allocate device memory

$$ copy host memory to device

$$ initialize thread block and kernel grid dimensions

$$ invoke CUDA kernel

$$ copy results from device to host

$$ deallocate device memory

$$ implement the tiled $2$D convolution kernel with adjustments for channels and make

sure to:

$-$use the constant memory for the convolution mask

$-$use shared memory to reduce the number of global accesses and handle the boundary

conditions when loading input list elements into the shared memory

$-$clamp your output values

Instructions about where to place each part of the code is demarcated by the $//$@@

comment lines.

Project Setup

To test your program on test$\_$case$\_0$:

Right click on the Convolution$\_$Template project $->$ Properties $->$ Configuration Properties $->$

Debugging $->$ Commmand Arguments and enter the following:

$-$e $.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$output$.$ppm

$-$i

$.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$input$0.$ppm$,.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$input$1.$raw

$-$o $.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$myoutput$.$ppm $-$t image $>$

$.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$result$.$txt

$($all in one line $$ do not forget to put spaces between the sub$$lines $$ above you see five

sub$$lines$)$

Here, input$0.$ppm is the input image and input$1.$raw is the mask.

You will see the output of your execution in result.txt which resides under

build$\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$

Command$$line Execution

The executable generated as a result of compiling the project $($build$\backslash$Debug$\backslash$

Convolution$\_$Template.exe$)$ can be run from the command$-$line using the following

command $($make sure you are in build directory$)$:

$.\backslash$Debug$\backslash$Convolution$\_$Template

$-$e $.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$output$.$ppm

$-$i

$.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$input$0.$ppm$,.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$input$1.$raw

$-$o $.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$myoutput$.$ppm $-$t image $>$

$.\backslash$Convolution$\backslash$Dataset$\backslash 0\backslash$result$.$txt

$($all in one line $$ do not forget to put spaces between the sub$$lines $$ above you see six

sub$$lines$)$