ORT BRAUDE COLLEGE OF ENGINEERING
Electronic and Electrical Engineering Department 
Client Server Systems and prallel programming 31261

PROJECT 5: Multithreading - running multiple threads

* Finally we approach the second topic: parallel programming

* We will focus on the Python threading and multiprocessing modules

* We are going to solve the following problems in the laboratory

* As an example of a computational problem that can be solved with parallel techniques is:
  Find the sum of all prime numbers less than 40000

* We will make an effort to complete the problem set at the lab, but whatever remains, you should
  complete at home (and get help from me using office hours or email)

* Please copy and paste the following code to a file named: proj5.py
------------------------------------------------------------------------
import sys, os, time, subprocess
from threading import Thread

# Find all prime numbers from a to b (excluding b)
def find_primes(a,b):
    primes = []
    p=a
    while p<b:
        if is_prime(p):
            primes.append(p)
            #sys.stdout.write(str(p)+':')
        p += 1
    return primes

def is_prime(p):
    i=2
    while i<p:
        if p%i==0:
           return False
        i += 1
    return True
------------------------------------------------------------------------


---------
PROBLEM 1
---------
Write a function sum_of_primes(n): for finding the sum of all prime numbers smaller than n.
Hint:
* Use the find_primes(a,b) in the file proj5.py
* Look at the Python function: sum()


---------
PROBLEM 2
---------
How much time does it take to compute sum_of_primes(40000) ?
Write a small function test1() that computes this time in seconds.
Use the Python module time, and the function time.time().
Hint:
Sum of primes < 40000 should give you: 79170666
Run Time on core i7 processor: about 6 seconds

---------
PROBLEM 3
---------
Write a Thread class PrimeSumThread for computing the sum of primes from a to b in a separate thread.
Make sure the class saves the sum, so it can be retrieved later by the main thread of the program!
Hint:
       class PrimeSumThread(Thread):
           def __init__(self, a, b):
               # fill this gap

           def run(self):
               # fill this gap

Hint:
Here is an example for testing your class:
    thread = PrimeSumThread(2,10)
    thread.start()
    thread.join()
    print thread.sum
    => 17

What will happen if you forget the 'thread.join()' statement ??
Try to comment this statement and see what happens?

---------
PROBLEM 4
---------
Run the following two threads concurrently:

    thread1 = PrimeSumThread(2, 200)
    thread2 = PrimeSumThread(200, 400)
    thread1. start()
    thread2. start()

How can you prove that this two threads are really running concurrently ?
Hint:
In find_primes() function, uncomment the line:
      #sys.stdout.write(str(i)+':')
and run the above code again

---------
PROBLEM 5
---------
(a) Use the PrimeSumThread class to write a function:

        def sum_of_primes_parallel(n):
            #code ...

    which computes the sum of primes smaller than the integer n, in 4 parallel threads.

(b) Write a small test2() for computing: sum_of_primes_parallel(40000)
    and measure the run time for this computation

Hint:
def sum_of_primes_parallel(n):
    thread = {}
    thread[0] = PrimeSumThread(2, n/4)
    thread[1] = PrimeSumThread(n/4, 2*n/4)
    thread[2] = PrimeSumThread(2*n/4, 3*n/4)
    thread[3] = PrimeSumThread(3*n/4, n)
    # continue from here ...
    # ......................

def test2():
   t1 = time.time()
   #code
   t2 = time.time()
   time = t2-t1

---------
PROBLEM 6
---------
What was the surprise you found in problem 4 ???
To solve this surprise we will need to resolt to the multiprocessing module:
goto project 6 ...