In Order to Study Parallel Programming Report Writing - Programming Assignment Help

Assignment Task

Task

Description
In order to study parallelism, we must have a problem that will take a significant amount of computation. We will generate images in the Mandelbrot set a well known fractal structure. The set is interesting both mathematically and aesthetically because it has an infinitely recursive structure. You can zoom into any part and find swirls, spirals, snowflakes, and other fun structures, as long as you are willing to do enough computation.

You will be provided a program that generates images of the Mandelbrot set and saves them as BMP files. Run make to build the code. If you run the program with no arguments, it generates a default image and writes it to mandel.bmp. You can see all of the command line options with mandel -h, and use them to override the defaults. This program uses the escape time algorithm. For each pixel in the image, it starts with the x and y position, and then computes a recurrence relation until it exceeds a fixed value or runs for max iterations.

Then, the pixel is assigned a color according to the number of iterations completed. An easy color scheme is to assign a gray value proportional to the number of iterations.

The max value controls the amount of work done by the algorithm. If we increase max, then we can see much more detail in the set, but it may take much longer to compute. Generally speaking, you need to turn the max value higher as you zoom in. For example, here is the same area in the set computed with four different values of max:

Parallel Programming
What does this all have to do with operating systems? It can take a long time to compute a Mandelbrot image. The larger the image, the closer it is to the origin, and the higher the max value, the longer it will take. Suppose that you want to create a movie of high resolution Mandelbrot images, and it is going to take a long time. Your job is to speed up the process by using multiple CPUs. You will do this in two different ways: using multiple processes and using multiple threads. 

Find an image
Explore the Mandelbrot space a little bit, and find an interesting area. The more you zoom in, the more interesting it gets, so try to get -s down to 0.0001 or smaller. Play around with -m to get the right amount of detail. Find a configuration that takes about 5 seconds to generate on omega. If you find an image that you like, but it only takes a second or two to create, then increase the size of the image using -W and -H, which will
definitely make it run longer. 

Part 1: Multiple Threads
Instead of running multiple programs at once, we can take a different approach of making each individual process faster by using multiple threads.
Modify mandel.c to use an arbitrary number of threads to compute the image. Each thread should compute a completely separate band of the image. For example, if you specify three threads and the image is 500 pixels high, then thread 0 should work on lines 0-165, thread 1 should work on lines 166-331, and thread 2 should work on lines 332-499. Add a new command line argument -n to allow the user to specify the number of threads. If -n is not given, assume a default of one thread. Your modified version of mandel should work correctly for any arbitrary number of threads and image configuration. Verify that your modified mandelseries produces the same output as the original.

Part 2: Evaluation Report
Write a short lab report that evaluates your parallel version:

• In your own words, briefly explain the purpose of the experiments and the experimental setup. Be sure to clearly state what your command line arguments were, so that your results can be reproduced to review your report.
• For the following two configurations, measure and graph the execution time of multithreaded mandel using 1, 2, 3, 4, 5, 10, and 50 threads. The execution time of these experiments may be upset by other things going on in the machine. So, repeat each measurement ten times, and use the fastest time achieved.
•  A: mandel -x -.5 -y .5 -s 1 -m 2000
•  B: mandel -x 0.2869325 -y 0.0142905 -s .000001 -W 1024 -H 1024 -m 1000
•  Explain the shape of the two curves. What is the optimal number of threads? Why do curves A and B have a different shape?

Code
The code for this assignment may be found on the course GitHub page at: https:// github.com/CSE3320/Fractal-Assignment

Grading
This assignment must be coded in C or C++. Any other language will result in 0 points. You programs will be compiled and graded on omega.uta.edu. Please make sure they compile and run on omega before submitting them. Code that does not compile on omega will result in a 0.
Good coding style, including clear formatting, sensible variable names, and useful comments. 

A correct implementation of multi-threaded Mandelbrot. 
A lab report which is clearly written using correct English, contains an appropriate description of your experiments, contains correct results that are clearly presented, and draws appropriate conclusions. 
Your programs are to be turned in via Canvas. Submission time is determined by the Canvas system time. You may submit your programs as often as you wish. Only your last submission will be graded.

This Programming Assignment has been solved by our Programming Expert at My Uni Paper. Our Assignment Writing Experts are efficient to provide a fresh solution to this question. We are serving more than 10000+ Students in Australia, UK & US by helping them to score HD in their academics. Our Experts are well trained to follow all marking rubrics & referencing Style. Be it a used or new solution, the quality of the work submitted by our assignment experts remains unhampered. 

You may continue to expect the same or even better quality with the used and new assignment solution files respectively. There’s one thing to be noticed that you could choose one between the two and acquire an HD either way. You could choose a new assignment solution file to get yourself an exclusive, plagiarism (with free Turn tin file), expert quality assignment or order an old solution file that was considered worthy of the highest distinction.