Changeset 1601

Timestamp:

Jul 12, 2005, 6:09:22 PM (19 years ago)

Author:

ole

Message:

Played with timestep reduction

Location:

inundation/ga/storm_surge/parallel

Files:

• parallel_shallow_water.py (modified) (5 diffs)
• run_parallel_sw_merimbula.py (modified) (2 diffs)

inundation/ga/storm_surge/parallel/parallel_shallow_water.py

@@ -60 +60 @@
         # Buffers for synchronisation of timesteps
         self.local_timestep = zeros(1, Float)
-        self.global_timestep = zeros(1, Float)        
+        self.global_timestep = zeros(1, Float)
+        
+        self.local_timesteps = zeros(self.numproc, Float)        
         
 
         self.communication_time = 0.0
         self.communication_reduce_time = 0.0
+        self.communication_broadcast_time = 0.0        
 
 
@@ -76 +79 @@
         assert self.conserved_quantities[2] == 'ymomentum', msg
 
-
-
-    def update_timestep(self, yieldstep, finaltime):
+ 
+    def update_timestep_1(self, yieldstep, finaltime):
+        """Calculate local timestep using broadcasts
+        """
+
+
+        Domain.update_timestep(self, yieldstep, finaltime)
+
+        import time
+
+
+        t0 = time.time()
+        
+        #Broadcast local timestep from every processor to every other
+        for pid in range(self.numproc):
+            #print 'P%d calling broadcast from %d' %(self.processor, pid)
+            self.local_timestep[0] = self.timestep                    
+            pypar.broadcast(self.local_timestep, pid, bypass=True)
+            self.local_timesteps[pid] = self.local_timestep[0]            
+
+        self.timestep = min(self.local_timesteps)
+            
+        self.communication_broadcast_time += time.time()-t0
+
+        
+
+    def update_timestep_2(self, yieldstep, finaltime):
 
         # Calculate local timestep
@@ -84 +111 @@
 
         import time
-        t0 = time.time()
+
+
+
+        self.local_timestep[0] = self.timestep
+
+
+
+        t0 = time.time()            
+        pypar.reduce(self.local_timestep, pypar.MIN, self.numproc-1,
+                     buffer=self.global_timestep,
+                     bypass=True)
+
+
+
+
+
+        if self.processor == self.numproc-1:
+            pypar.send(self.global_timestep, 0, use_buffer = True, bypass=True)
+
+        if self.processor == 0:
+            pypar.receive(self.numproc-1, buffer=self.global_timestep,
+                          bypass=True)   
+            
+        self.communication_reduce_time += time.time()-t0                        
+            
+
+        t0 = time.time()                        
+        pypar.broadcast(self.global_timestep, 0,
+                        bypass=True)
+        self.communication_broadcast_time += time.time()-t0
+
+        
+        self.timestep = self.global_timestep[0]
+
+
+            
+        #else:
+        #    #Try using straight send and receives
+        #    t0 = time.time()            
+        #    self.global_timestep[0] = self.timestep
+        #    
+        #    if self.processor == 0:
+        #        for i in range(1, self.numproc):
+        #            pypar.receive(i,
+        #                          buffer=self.local_timestep,
+        #                          bypass=True)#
+        #
+        #            if self.local_timestep[0] < self.global_timestep[0]:
+        #                self.global_timestep[0] = self.local_timestep[0]
+        #    else:
+        #        pypar.send(self.local_timestep, 0,
+        #                   use_buffer=True, bypass=True)
+        #    self.communication_reduce_time += time.time()-t0  
+
+
+
+    def update_timestep(self, yieldstep, finaltime):
+
+        # Calculate local timestep
+        Domain.update_timestep(self, yieldstep, finaltime)
+
+        import time
+
 
 
@@ -92 +181 @@
         use_reduce_broadcast = True
         if use_reduce_broadcast:
+            t0 = time.time()            
             pypar.reduce(self.local_timestep, pypar.MIN, 0,
                          buffer=self.global_timestep,
                          bypass=True)
-            
-            pypar.broadcast(self.global_timestep, 0,
-                            bypass=True)
+            self.communication_reduce_time += time.time()-t0            
+
+
+            
             
         else:
             #Try using straight send and receives
+            t0 = time.time()            
             self.global_timestep[0] = self.timestep
             
@@ -114 +206 @@
                 pypar.send(self.local_timestep, 0,
                            use_buffer=True, bypass=True)
+            self.communication_reduce_time += time.time()-t0                           
 
                 
-            pypar.broadcast(self.global_timestep, 0, bypass = True) 
+
+        t0 = time.time()                        
+        pypar.broadcast(self.global_timestep, 0,
+                        bypass=True)
+        self.communication_broadcast_time += time.time()-t0
 
         
         self.timestep = self.global_timestep[0]
-        self.communication_reduce_time += time.time()-t0
-
+
+
+    #update_timestep = update_timestep_2     
 
     def update_ghosts(self):

inundation/ga/storm_surge/parallel/run_parallel_sw_merimbula.py

@@ -145 +145 @@
                          ghost_recv_dict = ghost_recv_dict)
 
-#domain.initialise_visualiser(rect=rect)
 
-domain.initialise_visualiser(rect=rect)
-domain.visualiser.coloring['stage'] = True
-domain.visualiser.scale_z['stage'] = 0.2
-domain.visualiser.scale_z['elevation'] = 0.05
+try:
+    domain.initialise_visualiser(rect=rect)
+    domain.visualiser.coloring['stage'] = True
+    domain.visualiser.scale_z['stage'] = 0.2
+    domain.visualiser.scale_z['elevation'] = 0.05
+except:
+    print 'No visualiser'
 
 
@@ -190 +192 @@
     print 'Communication time %.2f seconds'%domain.communication_time
     print 'Reduction Communication time %.2f seconds'%domain.communication_reduce_time
+    print 'Broadcast time %.2f seconds'%domain.communication_broadcast_time