parallel Namespace Reference

Functions
def	Run_Parallel_Model (Parallelisation, Scheme, Mesh_File, Num_Modes, P, Num_Constants, Fit, BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core, Num_Core_Per_Socket, Num_Sock_Per_Node, PROC_TOT, Pressure, Velocity_1, Velocity_2, Velocity_3)
def	Run_Parallel_Comparison (Loc_Parallel_Timing_Files, Parallelisation, PROC_Z, PROC_XY, Total)

Function Documentation

Run_Parallel_Comparison()

def parallel.Run_Parallel_Comparison	(		Loc_Parallel_Timing_Files,
			Parallelisation,
			PROC_Z,
			PROC_XY,
			Total
	)

Definition at line 151 of file parallel.py.

def Run_Parallel_Comparison(Loc_Parallel_Timing_Files, Parallelisation, PROC_Z, PROC_XY, Total):
 
    if (Parallelisation is 'Modal'):
        Timings_Fin = {}
        Data = []
 
        (Nektar_Modes_Fin, Timing_Files_Fin) = Find_Nektar_Files(Loc_Parallel_Timing_Files)
 
        for i in range(0, len(Timing_Files_Fin)):
            Data.append(np.mean(Parse_Nektar_Output(Loc_Parallel_Timing_Files + Timing_Files_Fin[i]))/10) 
 
        # Calculate the mean, standard deviation and variance of the difference between the data and the fitted model
        difference = []
 
        for i in range(0, len(Timing_Files_Fin)):
            difference.append(abs(Data[i] - Total[i]))
        
        mean_diff = np.mean(difference) 
        std_dev_diff = np.std(difference)
        var_diff = np.var(difference)
        
        # Print these results for the user to see
        print('The mean of the differences between the Data and the Model is ' + str(mean_diff))
        print('The standard deviation of the differences between the Data and the Model is ' + str(std_dev_diff))
        print('The variance of the differences between the Data and the Model is ' + str(var_diff))
            
        fig, ax = plt.subplots()
        ax.plot(PROC_Z, Data, label = 'Data')
        ax.plot(PROC_Z, Total, label = 'Model')
        ax.set_xlabel('$ R_Z $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model vs Data')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Mode_Full.png")
 
    if (Parallelisation is 'Elemental'):
        Timings_Fin = {}
        Data = []
 
        (Nektar_Modes_Fin, Timing_Files_Fin) = Find_Nektar_Files(Loc_Parallel_Timing_Files)
 
        for i in range(0, len(Timing_Files_Fin)):
            Data.append(np.mean(Parse_Nektar_Output(Loc_Parallel_Timing_Files + Timing_Files_Fin[i]))/10)
 
        # Calculate the mean, standard deviation and variance of the difference between the data and the fitted model
        difference = []
 
        for i in range(0, len(Timing_Files_Fin)):
            difference.append(abs(Data[i] - Total[i]))
        
        mean_diff = np.mean(difference) 
        std_dev_diff = np.std(difference)
        var_diff = np.var(difference)
        
        # Print these results for the user to see
        print('The mean of the differences between the Data and the Model is ' + str(mean_diff))
        print('The standard deviation of the differences between the Data and the Model is ' + str(std_dev_diff))
        print('The variance of the differences between the Data and the Model is ' + str(var_diff))
 
        fig, ax = plt.subplots()
        ax.plot(PROC_XY, Data, label = 'Data')
        ax.plot(PROC_XY, Total, label = 'Model')
        ax.set_xlabel('$ R_{XY} $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model vs Data')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Element_Full.png")
 
    if (Parallelisation is 'Hybrid_Socket' or Parallelisation is 'Hybrid_Node'):
        Data = []
 
        (Nektar_Modes_Fin, Timing_Files_Fin) = Find_Nektar_Files(Loc_Parallel_Timing_Files)
 
        for i in range(0, len(Timing_Files_Fin)):
            Data.append(np.mean(Parse_Nektar_Output(Loc_Parallel_Timing_Files + Timing_Files_Fin[i]))/10)
 
        # Calculate the mean, standard deviation and variance of the difference between the data and the fitted model
        difference = []
 
        for i in range(0, len(Timing_Files_Fin)):
            difference.append(abs(Data[i] - Total[i]))
        
        mean_diff = np.mean(difference) 
        std_dev_diff = np.std(difference)
        var_diff = np.var(difference)
        
        # Print these results for the user to see
        print('The mean of the differences between the Data and the Model is ' + str(mean_diff))
        print('The standard deviation of the differences between the Data and the Model is ' + str(std_dev_diff))
        print('The variance of the differences between the Data and the Model is ' + str(var_diff))
 
        fig, ax = plt.subplots()
        ax.plot(PROC_Z, Data, label = 'Data')
        ax.plot(PROC_Z, Total, label = 'Model')
        ax.set_xlabel('$ R_Z $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model vs Data')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Hybrid_Full.png")

References tinysimd.abs(), functions_main.Find_Nektar_Files(), and CG_Iterations.Parse_Nektar_Output().

Run_Parallel_Model()

def parallel.Run_Parallel_Model	(		Parallelisation,
			Scheme,
			Mesh_File,
			Num_Modes,
			P,
			Num_Constants,
			Fit,
			BW_Node_To_Node,
			LAT_Node_To_Node,
			BW_Socket_To_Socket,
			LAT_Socket_To_Socket,
			BW_Core_To_Core,
			LAT_Core_To_Core,
			Num_Core_Per_Socket,
			Num_Sock_Per_Node,
			PROC_TOT,
			Pressure,
			Velocity_1,
			Velocity_2,
			Velocity_3
	)

Definition at line 33 of file parallel.py.

    Velocity_3):
 
    # Find possible topologies when running in hybrid
    if (Parallelisation is 'Hybrid_Socket' or Parallelisation is 'Hybrid_Node'):
        (PROC_XY, PROC_Z) = Find_Topologies(PROC_TOT, Num_Modes)
 
    # Modal parallelisation values
    if (Parallelisation is 'Modal'):
        PROC_Z = [2, 4, 5, 8, 10, 20]
        PROC_XY = [1, 1, 1, 1, 1, 1]
    
    # Elemental parallelisation values
    if (Parallelisation is 'Elemental'):
        PROC_Z = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
        PROC_XY = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
 
#------------------------------------
# Topology Class Input and Results
#------------------------------------
 
    Pairwise = []
    Allreduce = [] 
    Alltoall = []
 
    Communication = []
    Serial = []
 
    Serial_Pairwise = []
    Serial_Allreduce = []
    Serial_Alltoall = []
 
    Total = []
 
    for i in range(0, len(PROC_Z)):
 
        # Set the communication count to 0
        Communication_Count = 0.0
 
        # Create class instance with basic input
        Simulation = Topology(PROC_Z[i], PROC_XY[i], Num_Core_Per_Socket, Num_Sock_Per_Node, Scheme)
 
        # Find the partition for the number of PROC_XY input
        (Num_Element_Msg, Num_Elements) = Partition(Mesh_File, PROC_XY[i])
 
        # Input the benchmarked communication data
        Simulation.Input_Communication(BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core)
 
        # Distribute the modes and elements
        Simulation.Distribute_Modes(Num_Modes);
        Simulation.Distribute_Elements(Num_Element_Msg, Num_Elements);
    
        # Read in the CG iterations
        Simulation.CG_Iterations(Pressure, Velocity_1, Velocity_2, Velocity_3)
 
        # Input P to genererate the data sizes
        Simulation.Data_Size(P)
 
        # Input the fit from the serial model
        Simulation.Hardware_Constant(Num_Constants, Fit)
 
        # Count pairwise exchange
        Pairwise.append(Simulation.Communication_Pairwise_Exchange())
        Communication_Count += Pairwise[i]
    
        # Count Allreduce
        Allreduce.append(Simulation.Communication_Allreduce())
        Communication_Count += Allreduce[i]
 
        # Count Alltoall
        Alltoall.append(Simulation.Communication_Alltoall())
        Communication_Count += Alltoall[i]
 
        # Count Serial
        Serial.append(Simulation.Serial_Compute())
 
        # Count Serial with each type of communication
        Serial_Pairwise.append(Serial[i] + Pairwise[i])
        Serial_Allreduce.append(Serial[i] + Allreduce[i])
        Serial_Alltoall.append(Serial[i] + Alltoall[i])
 
        # Record the total communication
        Communication.append(Communication_Count)
 
        # Calculate the total length of a time step
        Total.append(Communication[i] + Serial[i])
    
    if (Parallelisation == 'Hybrid'):
        fig, ax = plt.subplots()
        ax.plot(PROC_Z, Total, label = 'Model')
        ax.set_xlabel('$ R_Z $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Model_Hybrid.png")
 
    if (Parallelisation == 'Modal'):
        fig, ax = plt.subplots()
        ax.plot(PROC_Z, Total, label = 'Model')
        ax.set_xlabel('$ R_Z $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Model_Modal.png")
 
    if (Parallelisation == 'Elemental'):
        fig, ax = plt.subplots()
        ax.plot(PROC_XY, Total, label = 'Model')
        ax.set_xlabel('$ R_{XY} $')
        ax.set_ylabel('Timestep (s)')
        ax.set_title('Length of Single Timestep: Model')
        plt.legend(loc=1)
        fig.savefig("Output/Figures/Model_Elemental.png")
 
    return(PROC_Z, PROC_XY, Total)
 
# Run a series of plots showing outputs of the model vs data

References functions_main.Find_Topologies(), and functions_main.Partition().