147
edits
Changes
→Introduction : GPU Benchmarking/Gaussian Blur Filter : Colin Paul
= Profiling Assignment 1 - Select and Assess =
== Introduction : GPU Benchmarking/Testing using Mandelbrot Sets : Kartik Nagarajan ==
|}
----
== Introduction : GPU Benchmarking/Gaussian Blur Filter : Colin Paul ==
[[Image:Cinque_terre.jpg|860px]][[Image:Cinque_terre_BLURRED.jpg|860px]]
[[Image:F2RiP.gif|500px|thumb|alt=convolution pattern]]
[[Image:Img16.png|500px|thumb|alt=Plot of frequency response of the 2D Gaussian]]
===What is a Gaussian blurringfilter blur?===
At a high level, Gaussian blurring works just like box blurring in that there is a weight per pixel and that for each pixel, you apply the weights to that pixel and it’s neighbors to come up<br/>
There are a couple ways to calculate a Gaussian kernel.
A better way is to use the Gaussian function which is this: e<sup>-x<sup>2</sup>/(2 * σ<sup>2</sup>)</sup>
Where the sigma is your blur amount and x ranges across your values from the negative to the positive. For instance , if your kernel was 5 values, it would range from -2 to +2.
An even better way would be to integrate the Gaussian function instead of just taking point samples. Refer to the diagram on the right.<br/>
Below you can find a plot of the continuous distribution function and the discrete kernel approximation. One thing to look out for are the tails of the distribution vs. kernel support:<br/>
For the current configuration , we have 13.36% of the curve’s area outside the discrete kernel. Note that the weights are renormalized such that the sum of all weights is one. Or in other words:<br/>
the probability mass outside the discrete kernel is redistributed evenly to all pixels within the kernel. The weights are calculated by numerical integration of the continuous gaussian distribution<br/>
over each discrete kernel tap. Take a look at the java script source in case you are interested.
Whatever way you do it, make sure and normalize the result so that the weights add up to 1. This makes sure that your blurring doesn’t make the image get brighter (greater than 1) or dimmer (less than 1).
speed versus quality.
Original source code (Windows) can be found [http://blog.demofox.org/2015/08/19/gaussian-blur/ here].
{| class="wikitable mw-collapsible mw-collapsed"
#include <vector>
#include <functional>
#include <windows.h> // for bitmap headers. Sorry non windows people!
const float c_pi = 3.14159265359f;
#include <vector>
#include <functional>
#include "windows.h" // for bitmap headers. Sorry non windows people!
/* uncomment the line below if you want to run grpof */
|}
Flat profile:
=== Observations ===
The program does not take a long time to run, but runtime run-time depends on the values of sigma (σ) and the kernel block size. If you specify larger values for these parameters the runtime increases<br/>significantly. The code is relatively straight forward and the parallelization should also be easy to implement and test.
=== Hotspot ===
Referring to the Call graph we can see more supporting evidence that this application spends nearly all of its execution time in the BlurImage function. Therefore this function is the prime candidate<br/>
for parallelization using CUDA. The sigma (σ) and the kernel size can be increased in order to make the computation stressful on the GPU to get a significant benchmark.
= Assignment 2 - Parallelize =
= Assignment 3 - Optimize =