1
edit
Changes
→Assignment 2
I decided to scrap the randomization part of the original program for now because I want to have consistent profile results every run. I chose to focus on the seed found [http://maximecb.github.com/Turing-Drawings/#6,4,1,2,0,1,3,1,4,3,3,1,3,0,5,2,1,4,2,0,2,1,1,4,1,0,1,3,0,5,1,3,1,1,3,0,1,1,2,3,3,5,1,1,3,1,0,3,1,2,1,1,1,1,3,3,3,2,2,2,3,3,2,1,3,5,3,0,2,3,2,4,1,1 here] because who doesn't love the Matrix. I also decided to only generate 1000 images each time the program is run.
After profiling I determined that 99% of the run was being spent in two functions, 89% and 10% respectively. It's also interesting to note that the function that took 89% gets called 70000 times. The code for the two functions is below.
<source lang="cpp">
</source>
<source lang="cpp">
void updateRender(tmach::Program* program) {
float startTime = tmach::getTimeMillis();
int startItrc = program->itrCount;
// Until the update time is exhausted
do {
// Update the program
program->update(5000);
float curTime = tmach::getTimeMillis();
int curItrc = program->itrCount;
if (curItrc - startItrc >= UPDATE_ITRS ||
curTime - startTime >= UPDATE_TIME)
break;
} while (true);
// Produce the image data
int* map = program->map;
int map_size = program->size_map;
unsigned char data [WIDTH * HEIGHT * 3];
for (int i = 0; i < program->size_map; ++i)
{
int sy = map[i];
int r = colorMap[3 * sy + 0];
int g = colorMap[3 * sy + 1];
int b = colorMap[3 * sy + 2];
data[3 * i + 0] = r;
data[3 * i + 1] = g;
data[3 * i + 2] = b;
}
// Show the image data
tmach::createBMP(WIDTH, HEIGHT, data, WIDTH*HEIGHT*4, "temp.bmp");
}
</source>
Because ~90% of the run time is take up by one function it's really the only possible candidate for moving to the GPU and optimizing. Upon closer inspection though you can see that the update function only contains one for loop and the for loop essentially snakes through the image map 1 pixel at a time. I don't think it can be parallelized because each iteration is dependent on the one before. The image creation is reliant on the snaking effect.
'''Analysis:'''
=== Assignment 2 ===
For the second assignment we couldn't choose to do either of our topics for Assignment 1. We decided to do a variation on Conway's Game of Life called SmoothLife. We started with [http://0fps.wordpress.com/2012/11/19/conways-game-of-life-for-curved-surfaces-part-1/ this blog post]. The author goes into great detail about the math behind SmoothLife, but you don't really need to understand it. At the bottom of the post there is a JavaScript implementation of SmoothLife, [http://jsfiddle.net/mikola/aj2vq/ here], and we used that as a starting point.
In order to profile the code I ported it over to C++ and ran it on Matrix. The results weren't great. The two functions that consumed the most run time took up a total of 90% of the time, but each run of the function only took 0.01ms. So both of those were out because it wouldn't be worth it. The next two functions took up ~15% runtime combined. We each picked on and moved it to the GPU. We new the results weren't going to be great, but I'm sick of porting JavaScript to C++.
Actual source code to follow.
=== Assignment 3 ===
