optimized sharing among processors

Author: giadarol

004_estimated_scaling.py

@@ -0,0 +1,37 @@
+import pylab as pl
+import numpy as np
+
+N_segments = 35
+i_end_parallel = N_segments
+
+N_per_worker_list = []
+N_master_list = []
+N_nodes_list = range(2,N_segments+1) 
+for N_nodes in N_nodes_list:
+	N_per_worker = N_segments/(N_nodes-1)
+	N_master = N_segments-(N_nodes-1)*N_per_worker
+	
+	N_per_worker_list.append(N_per_worker)
+	N_master_list.append(N_master)
+	
+pl.figure(1)	
+pl.plot(N_per_worker_list, 'b.-')
+pl.plot(N_master_list, 'r.-')
+
+N_per_worker_list = []
+N_master_list = []
+N_nodes_list = range(2,N_segments+1) 
+for N_nodes in N_nodes_list:
+	N_wkrs = N_nodes-1
+	N_per_worker = int(np.ceil(float(i_end_parallel)/N_nodes))
+
+	N_master = N_segments-(N_nodes-1)*N_per_worker
+	
+	N_per_worker_list.append(N_per_worker)
+	N_master_list.append(N_master)
+	
+pl.figure(2)	
+pl.plot(N_per_worker_list, 'b.-')
+pl.plot(N_master_list, 'r.-')
+
+pl.show()

share_segments.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+class ShareSegments(object):
+	def __init__(self, N_segments, N_nodes):
+		self.N_segments_per_node = np.array(N_nodes*[N_segments//N_nodes])
+		rem = N_segments-N_segments//N_nodes*N_nodes
+		self.N_segments_per_node[:rem]+=1
+		self.start_parts = np.array([0]+list(np.cumsum(self.N_segments_per_node)))
+		
+	def my_part(self, myid):
+		return self.start_parts[myid], self.start_parts[myid+1]
+

test_ring_with_objects/Simulation.py

@@ -1,6 +1,7 @@
 import communication_helpers as ch
 import numpy as np
 from scipy.constants import c
+import share_segments as shs
 
 
 class Simulation(object):
@@ -22,15 +23,13 @@ def init_all(self):
 		i_end_parallel = len(self.machine.one_turn_map)-1 #only RF is not parallelizable
 
 		# split the machine
-		N_wkrs = self.ring_of_CPUs.N_wkrs 	
-		N_elements_per_worker = int(np.floor(float(i_end_parallel)/N_wkrs))
+		sharing = shs.ShareSegments(i_end_parallel, self.ring_of_CPUs.N_nodes)
 		myid = self.ring_of_CPUs.myid
-		print 'N_elements_per_worker', N_elements_per_worker
+		i_start_part, i_end_part = sharing.my_part(myid)
+		self.mypart = self.machine.one_turn_map[i_start_part:i_end_part]
 		if self.ring_of_CPUs.I_am_a_worker:
-			self.mypart = self.machine.one_turn_map[N_elements_per_worker*myid:N_elements_per_worker*(myid+1)]
-			print 'I am id=%d and my part is %d long'%(myid, len(self.mypart))
+			print 'I am id=%d (worker) and my part is %d long'%(myid, len(self.mypart))
 		elif self.ring_of_CPUs.I_am_the_master:
-			self.mypart = self.machine.one_turn_map[N_elements_per_worker*(N_wkrs):i_end_parallel]
 			self.non_parallel_part = self.machine.one_turn_map[i_end_parallel:]
 			print 'I am id=%d (master) and my part is %d long'%(myid, len(self.mypart))
 
@@ -80,7 +79,7 @@ def finalize_turn_on_master(self, pieces_treated):
 		for ele in self.non_parallel_part:
 			ele.track(bunch)
 
-		#csave results
+		#save results
 		self.beam_x.append(bunch.mean_x())
 		self.beam_y.append(bunch.mean_y())
 		self.beam_z.append(bunch.mean_z())

test_ring_with_objects/Simulation_with_eclouds.py

@@ -1,6 +1,7 @@
 import communication_helpers as ch
 import numpy as np
 from scipy.constants import c, e
+import share_segments as shs
 
 
 class Simulation(object):
@@ -24,15 +25,13 @@ def init_all(self):
 		i_end_parallel = len(self.machine.one_turn_map)-1 #only RF is not parallelizable
 
 		# split the machine
-		N_wkrs = self.ring_of_CPUs.N_wkrs 	
-		N_elements_per_worker = int(np.floor(float(i_end_parallel)/N_wkrs))
+		sharing = shs.ShareSegments(i_end_parallel, self.ring_of_CPUs.N_nodes)
 		myid = self.ring_of_CPUs.myid
-		print 'N_elements_per_worker', N_elements_per_worker
+		i_start_part, i_end_part = sharing.my_part(myid)
+		self.mypart = self.machine.one_turn_map[i_start_part:i_end_part]
 		if self.ring_of_CPUs.I_am_a_worker:
-			self.mypart = self.machine.one_turn_map[N_elements_per_worker*myid:N_elements_per_worker*(myid+1)]
-			print 'I am id=%d and my part is %d long'%(myid, len(self.mypart))
+			print 'I am id=%d (worker) and my part is %d long'%(myid, len(self.mypart))
 		elif self.ring_of_CPUs.I_am_the_master:
-			self.mypart = self.machine.one_turn_map[N_elements_per_worker*(N_wkrs):i_end_parallel]
 			self.non_parallel_part = self.machine.one_turn_map[i_end_parallel:]
 			print 'I am id=%d (master) and my part is %d long'%(myid, len(self.mypart))