thread.cpp

Fibonacci: F0 = 1; F1 = 1; Fi = Fi-1 + Fi-2;

In this project you will create ONE program - a threaded program.
(Don't forget to use ipcs and ipcrm before you leave albert!)

Each thread will be responsible for computing a portion of the
Fibonacci numbers (use the explosive recursive version), similar
to the children in the previous program. The original thread will
call a number of threaded processes to do the computation.

Example execution: ./thread 0 100 3
(computes fibonacci #s 0 through 100 with 3 threads).  The original
thread must not call join before the last thread is created.


Each thread is responsible for computing the fibonacci #s in the
interval passed as an argument and store them in some global
memory array where appropriate. Have your thread call your fibonacci
function separately for each value in the interval, rather than doing
something more clever and efficient. The point is to show the value of
threads, not clever fibonacci calculations. Also, use an
explosive recursive version of fibonacci and not iterative. If you're
unsure how to do this, please see me.

The original thread will wait for all threads  to finish.  When they have
completed, it will output the entire interval requested.

Readme:

1.  Report any problems you have or suggestions for this
    assignment. Make some comment here if you want full credit for
    your readme.

2.  Use the unix time command to test timing results for different
    executions. In particular, run and report the timings below (this
    will take some time to finish execution, so be patient). If you
    find that your first process finishes in less than 5 seconds, make
    sure you're using recursive and separate Fibonacci function calls.
    If you're convinced that you are, increase the interval size up
    until you get timings well above 5 seconds. This may result in
    "fake" Fibonacci numbers, but it will give your timing results
    more meaning.

time ./thread 1 40 1
time ./thread 1 40 2
time ./thread 1 40 3
time ./thread 1 40 10
time ./thread 40 40 1

3.  Comment on the differences in time and use your own words to
    describe that difference. Compare these times to your previous
    times using fork with shared memory and comment. If you used the
    modulus or a 'pattern' from the previous assignment, please do so
    again to compare your timings.


Extra Credit: Come up with your own pattern for balancing the load
   between threads/children that does a better job than strict
   intervals (1-2 and 3-4) or modulus (1,3 and 2,4). Report the
   timings for both forks and threads.