Changeset 3184

Timestamp:

Jun 20, 2006, 11:24:38 AM (18 years ago)

Author:

linda

Message:

Changed parallel_advection so the timestep size is updated straight
after the flux calculation. Also added results for advection on the
Merimbula grid

Location:

inundation/parallel

Files:

• build_commun.py (modified) (1 diff)
• documentation/code/RunParallelAdvection.py (modified) (2 diffs)
• documentation/code/RunParallelMerimbulaMetis.py (modified) (2 diffs)
• documentation/results.tex (modified) (1 diff)
• parallel_advection.py (modified) (2 diffs)
• run_parallel_advection_prof.py (modified) (2 diffs)

inundation/parallel/build_commun.py

@@ -27 +27 @@
     pass
 
-
 import sys
-from pypar_dist import pypar
+
+#from pypar_dist import pypar
+import pypar
 
 from build_local import build_local_mesh

inundation/parallel/documentation/code/RunParallelAdvection.py

@@ -25 +25 @@
 #  Mesh partition routines
 
-from parallel_meshes import parallel_rectangle
+from parallel.parallel_meshes import parallel_rectangle
 
 # Parallel Domain
  
-from parallel_advection import Parallel_Domain
-from parallel_advection import Transmissive_boundary
+from parallel.parallel_advection import Parallel_Domain
+from parallel.parallel_advection import Transmissive_boundary
 
 ############################
@@ -117 +117 @@
     print 'Reduction Communication time %.2f seconds'\
           %domain.communication_reduce_time
+
+

inundation/parallel/documentation/code/RunParallelMerimbulaMetis.py

@@ -40 +40 @@
 # pmesh
 
-from pmesh2domain import pmesh_to_domain_instance
-from advection import Domain as Advection_Domain
-from parallel_advection import Parallel_Domain
+from pyvolution.pmesh2domain import pmesh_to_domain_instance
+from pyvolution.advection import Domain as Advection_Domain
+from parallel.parallel_advection import Parallel_Domain
 
-from generic_boundary_conditions import Transmissive_boundary
+from pyvolution.generic_boundary_conditions import Transmissive_boundary
 
 # Mesh partition routines
 
-from pmesh_divide  import pmesh_divide_metis
-from build_submesh import build_submesh
-from build_local   import build_local_mesh
-from build_commun  import send_submesh, rec_submesh, extract_hostmesh
+from parallel.pmesh_divide  import pmesh_divide_metis
+from parallel.build_submesh import build_submesh
+from parallel.build_local   import build_local_mesh
+from parallel.build_commun  import send_submesh, rec_submesh, extract_hostmesh
 
 
@@ -88 +88 @@
     # Read in the test files
 
-    filename = 'merimbula_10785.tsh'
+    filename = 'parallel/merimbula_10785.tsh'
 
     mesh_full = pmesh_to_domain_instance(filename, Advection_Domain)

inundation/parallel/documentation/results.tex

@@ -78 +78 @@
 
 
-Another way of measuring the performance of the code on a parallel machine is to increase the problem size as the number of processors are increased so that the number of triangles per processor remains roughly the same.  We have node carried out measurements of this kind as we usually have static grids and it is not possible to increase the number of triangles.  
+Another way of measuring the performance of the code on a parallel machine is
+to increase the problem size as the number of processors are increased so that
+the number of triangles per processor remains roughly the same.  We have node
+carried out measurements of this kind as we usually have static grids and it
+is not possible to increase the number of triangles.
+  
+\section{Advection, Merimbula Mesh}
+
+We now look at another advection example, except this time the mesh comes from
+the Merimbula test problem. Inother words, we ran the code given in Section
+\ref{subsec:codeRPMM}, except the final time was reduced to 10000
+(\code{\label{subsec:codeRPMM}). The results are given in Table \ref{tbl:rpm}.
+These are good efficiency results, especially considering the structure of the
+Merimbula mesh. Note that since we are solving an advection problem the amount
+of calculation done on each triangle is relatively low, when we more to other
+problems that involve more calculations we would expect the computation to
+communication ratio to increase and thus get an increase in efficiency.
+
+\begin{table} 
+\caption{Parallel Efficiency Results for the Advection Problem on the
+  Merimbula Mesh {\tt N} = 160, {\tt M} = 160.\label{tbl:rpm}}
+\begin{center}
+\begin{tabular}{|c|c c|}\hline
+$n$ & $T_n$ (sec) & $E_n (\%)$ \\\hline
+1 &145.17 & \\
+2 &77.52 & 94 \\
+4 & 41.24 & 88 \\
+8 & 22.96 & 79 \\\hline
+\end{tabular}
+\end{center}
+\end{table}

inundation/parallel/parallel_advection.py

@@ -67 +67 @@
     def update_timestep(self, yieldstep, finaltime):
 
-        # Calculate local timestep
-        Domain.update_timestep(self, yieldstep, finaltime)
+        #LINDA:
+        # moved the calculation so that it is done after timestep
+        # has been broadcast
+        
+#        # Calculate local timestep
+#        Domain.update_timestep(self, yieldstep, finaltime)
 
         import time
@@ -78 +82 @@
         ltimestep[0] = self.timestep
         gtimestep = zeros( 1, Float) # Buffer for results
-
+        
         pypar.raw_reduce(ltimestep, gtimestep, pypar.MIN, 0)
         pypar.broadcast(gtimestep,0)
 
         self.timestep = gtimestep[0]
-
+        
         self.communication_reduce_time += time.time()-t0
 
+        # LINDA:
+        # Now update time stats
+        
+        # Calculate local timestep
+        Domain.update_timestep(self, yieldstep, finaltime)
 
     def update_ghosts(self):

inundation/parallel/run_parallel_advection_prof.py

@@ -55 +55 @@
 processor_name = pypar.Get_processor_name()
 
-N = 320
-M = 320
+N = 80
+M = 80
 
 #######################
@@ -110 +110 @@
 import hotshot
 profiler = hotshot.Profile("hotshot." + str(numprocs) + "." + str(myid) + ".prof")
-s = '''for t in domain.evolve(yieldstep = 0.1, finaltime = 0.2):
+s = '''for t in domain.evolve(yieldstep = 0.1, finaltime = 2.0):
   if myid == 0:
     domain.write_time()
 '''
-#PUT BACK
-#import hotshot
-#profiler = hotshot.Profile("hotshot." + str(numprocs) + "." + str(myid) + ".prof")
-#s = '''for t in domain.evolve(yieldstep = 0.1, finaltime = 10):
-#  if myid == 0:
-#    domain.write_time()
-#'''