Our Code - Revision history

Wikiuser at 09:46, 19 March 2016

2016-03-19T09:46:01Z

Wikiuser at 09:45, 19 March 2016

2016-03-19T09:45:54Z

Wikiuser: Replaced content with "Serial and Parallel Pi Calculation"

2016-03-02T22:41:38Z

Replaced content with "Serial and Parallel Pi Calculation"

Show changes

Wikiuser at 18:39, 2 March 2016

2016-03-02T18:39:41Z

Wikiuser at 18:28, 2 March 2016

2016-03-02T18:28:34Z

Wikiuser at 17:26, 2 March 2016

2016-03-02T17:26:20Z

Wikiuser at 16:52, 2 March 2016

2016-03-02T16:52:48Z

Wikiuser at 16:43, 2 March 2016

2016-03-02T16:43:09Z

Wikiuser at 06:03, 28 February 2016

2016-02-28T06:03:52Z

Wikiuser at 06:02, 28 February 2016

2016-02-28T06:02:26Z

← Older revision		Revision as of 09:46, 19 March 2016
Line 1:		Line 1:
	[[Serial and Parallel Pi Calculation]]		[[Serial and Parallel Pi Calculation]]
		+
	[[Decision Forests]]		[[Decision Forests]]

← Older revision		Revision as of 09:45, 19 March 2016
Line 1:		Line 1:
	[[Serial and Parallel Pi Calculation]]		[[Serial and Parallel Pi Calculation]]
		+	[[Decision Forests]]

@@ Line 76: / Line 76: @@
      comm = MPI.COMM_WORLD                              # comm is an mpi4py.MPI object representing the "world" of the cluster.
      rank = comm.Get_rank()                             # That is, all the nodes and all the CPUs of the nodes, etc.
-     if rank == 0:                                      # Each cpu on each node is given an integer "rank" (0, 1, 2, 3,...)
+     if rank == 0:     # The head does this if block    # Each cpu on each node is given an integer "rank" (0, 1, 2, 3,...)
          start = time.time()                            # Usually, rank 0 is called the "head" node and assigns jobs to the
          i = int(sys.argv[1])                           # higher-ranked "worker" nodes. The worker nodes do their jobs and
@@ Line 99: / Line 99: @@
              print(pi)
              print("MPI pi approx time: {} seconds".format(elapsed))
-     else:                                              # The workers do this block.
+     else:                                              # The workers each do this block.
          data = comm.recv(source=0)                     # They receive the list of terms to calculate, do the calculation and
          pi_appr = nthTerm(data)                        # send the result back to the head

@@ Line 81: / Line 81: @@
          size = comm.Get_size()                         # subsequently send the results back to the head node to assemble and
          workers = size - 1                             # collate.
-         termsplits = []
+         termsplits = []                                # initialize a list for splitting the task up among the workers.
-         for x in range(workers):
+         for x in range(workers):                       # termsplits is a list of lists of terms the workers will compute
-             termsplits.append(xrange(x, i+1, workers))
+             termsplits.append(xrange(x, i+1, workers)) # (different for each worker)
-         for y, data in enumerate(termsplits):
+         for y, data in enumerate(termsplits):          # This block sends data (a list of terms) to each worker
              dest = y + 1
              if dest >= size:
@@ Line 91: / Line 91: @@
                  comm.send(data, dest=dest)
          pi = 0
-         for y in range(workers):
+         for y in range(workers):                       # In this block, the head receives the results from the workers and
-             source = y + 1
+             source = y + 1                             # adds them together to calculate pi
              print("Waiting for source:{}".format(source))
              pi_appr = comm.recv(source=source)
@@ Line 99: / Line 99: @@
              print(pi)
              print("MPI pi approx time: {} seconds".format(elapsed))
-     else:
+     else:                                              # The workers do this block.
-         data = comm.recv(source=0)
+         data = comm.recv(source=0)                     # They receive the list of terms to calculate, do the calculation and
-         pi_appr = nthTerm(data)
+         pi_appr = nthTerm(data)                        # send the result back to the head
          comm.send(pi_appr, dest=0)

@@ Line 74: / Line 74: @@
 def main():
-     comm = MPI.COMM_WORLD
+     comm = MPI.COMM_WORLD                              # comm is an mpi4py.MPI object representing the "world" of the cluster.
-     rank = comm.Get_rank()
+     rank = comm.Get_rank()                             # That is, all the nodes and all the CPUs of the nodes, etc.
-     if rank == 0:
+     if rank == 0:                                      # Each cpu on each node is given an integer "rank" (0, 1, 2, 3,...)
-         start = time.time()
+         start = time.time()                            # Usually, rank 0 is called the "head" node and assigns jobs to the
-         i = int(sys.argv[1])
+         i = int(sys.argv[1])                           # higher-ranked "worker" nodes. The worker nodes do their jobs and
-         size = comm.Get_size()
+         size = comm.Get_size()                         # subsequently send the results back to the head node to assemble and
-         workers = size - 1
+         workers = size - 1                             # collate.
          termsplits = []
          for x in range(workers):

@@ Line 35: / Line 35: @@
      print("Elapsed time: {}.".format(elapsed))
-if __name__ == '__main__':
+if __name__ == '__main__':                                              # this bit of code allow for using this program as a
-     main()
+     main()                                                              # standalone program or as a module
 </pre>
 This is simple enough, maybe you've even written something similar.  I'll go over a few things.

@@ Line 11: / Line 11: @@
 import sys
 import time
-from decimal import *
+from decimal import *                                                # Python package for intuitive handling decimal numbers
 getcontext().prec = 50
 def piApprox(n):
@@ Line 20: / Line 20: @@
      """
      pi = 0
      for i in xrange(n+1):
-         sign = 1 if i % 2 == 0 else -1
+         sign = 1 if i % 2 == 0 else -1                                # sign is +1 if i is even and -1 if i is odd
-         pi += Decimal(sign * 2 * 3 ** (.5-i)) / Decimal(2 * i + 1)
+         pi += Decimal(sign * 2 * 3 ** (.5-i)) / Decimal(2 * i + 1)    # Madhava-Leibniz series approximation for pi
      return pi
 def main():
-     n = sys.argv[1]
+     n = sys.argv[1]                                                    # requires the program be called with a command line
-     n = int(n)
+     n = int(n)                                                         # argument specifying the desired number of terms
      start = time.time()
      pi = piApprox(n)

@@ Line 40: / Line 40: @@
 This is simple enough, maybe you've even written something similar.  I'll go over a few things.
-If you are unfamiliar with python 2.7, the line at the top -- from __future__ import division -- probably looks strange to you.  All this is doing is telling python to compute divisions as floats and to not do integer division (that would really mess up our approximation).
+-If you are unfamiliar with python 2.7, the line at the top -- from __future__ import division -- probably looks strange to you.  All this is doing is telling python to compute divisions as floats and to not do integer division (that would really mess up our approximation).
 sys.argv[1] is telling python to take a look at the 1 index of the commandline arguments (where index 0 is the name of the file you are running)
 For example, we would run this file like

@@ Line 43: / Line 43: @@
 sys.argv[1] is telling python to take a look at the 1 index of the commandline arguments (where index 0 is the name of the file you are running)
 For example, we would run this file like
 [[File:piserial.png]]
 We can see the elapsed time was 3.26 seconds.
 Then we just run the piApprox(n) function and add up our n terms.