parallel Namespace Reference

Functions
def	Run_Parallel_Model
def	Run_Parallel_Comparison

Function Documentation

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

Definition at line 151 of file parallel.py.

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

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")

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 35 of file parallel.py.

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

    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)