CS345 - Software Engineering - Spring 2008
Charlie Peck
Department of Computer Science - Earlham College

Hypothesis - For most cases there is a "right" order in which to visit large arrays

For this assignment you will need to:

• Design and write a piece of code (in your favorite portable language) that creates a local (to the function in which it is used) x by y array of chars and then visits each location in the array, assigning a value to it, in each of the possible traversal orders.

• Time your software in each of the possible configurations on cs.earlham.edu, on a Cairo node, and on one of the ACL machines.

• Some tips and guidlines:
  • Make it easy to generate and collect the results by having the timing and such embedded either in the code or in a driver script.

  • The load on these machines varies, and there are natural variances when you run software, so take the average of a number of runs (at least 3) for each measurement you make. This can also be built-in to the code or driver script. If you want to see what the load on a machine is you can use vmstat -3 or top.

  • Before doing any runs use ulimit to set the maximum size of a stack frame to 8MB (or the maximum for that platform) for your process tree.

  • Use -O0 to make sure the compiler doesn't do any optimization.

• The data you collect should include each of the following:

    cs.earlham.edu  
                      100x      1000x      ?x
                      100       1000       ?           
            x -> y    some #    some #    some #  
            y -> x    some #    some #    some #  
    
    aclx.cs.earlham.edu
                      100x      1000x      ?x
                      100       1000       ?           
            x -> y    some #    some #    some #  
            y -> x    some #    some #    some #  
    
    cx.cairo.cluster.earlham.edu
                      100x      1000x      ?x
                      100       1000       ?           
            x -> y    some #    some #    some #  
            y -> x    some #    some #    some #  
    

  You will have to experiment to see what the largest array of chars is when the two dimensions are equal (100 x 100, 1000 x 1000, 2343 x 2343, etc.) Use this size for the third column. Make sure it's as large as possible. N.B. This will vary by platform. Once you have determined what they are your code should detect the underlying platform and use the appropriate conditionals to set the value of that maximum automatically at build time.

• The "some #" values should be calculated as the average of at least three separate runs. That is you do three runs of x -> y on a 1000 x 1000 array on millie, average those values, and use that value for "some #" in the appropriate place.

• Graph and interpret the results. Write-up a summary of the process, your code, and your results. If there is a difference in performance depending on which traversal is used why is this? Support your conclusion with additional data if possible.

• You should turn-in a printout of your code, a graph of the results (for each traversal on each platform), and a short (1-2 paragraph) write-up of what you observed and why. Style counts.

• For extra credit:
  1. What happens when the array is global rather than local? Why?

  2. What can you learn with gprof rather than time for this analysis? Demonstrate.

  3. What happens with three dimensional arrays? Why?