main.py

Go to the documentation of this file.

# Andrew Gloster
# Summer 2016
# Python Version of Communication Model Implementation
# Main Program
 
#------------------------------------
# Import relevant modules
#------------------------------------
 
import os
from subprocess import Popen, PIPE
 
#------------------------------------
# Import relevant main functions
#------------------------------------
 
from functions_main import PBS_Job_Parse
from functions_main import PBS_Benchmark_Parse
from functions_main import Parse_Benchmark
from functions_main import Parse_Nektar_Output
from functions_main import Parse_Nektar_CG_Benchmark_Output
from functions_main import Find_Nektar_Elements
from functions_main import Find_Nektar_Files
from functions_main import Find_Hardware
from functions_main import Find_Conditions
from functions_main import Filename_Generate
 
#------------------------------------
# Import function for serial computation
#------------------------------------
 
from serial import Run_Serial_Fit
 
#------------------------------------
# Import function for parallel model
#------------------------------------
 
from parallel import Run_Parallel_Model
from parallel import Run_Parallel_Comparison
 
#------------------------------------
# Import relevant error checking functions
#------------------------------------
 
from error_main import Primary_Error_Out
from error_main import Error_Check_Proc_Input
from error_main import Error_Check_Comm_Input
 
#------------------------------------
# Main Program Begin
#------------------------------------
 
#------------------------------------
# User Model Choices
#------------------------------------
 
# Input the mesh file name, stored in Input/Mesh/
Mesh = 'cyl-small.xml'
 
# Maximum value of N_Z
Max_N_Z = 'output_72.txt'
 
# Input the conditions file name stored in Input/Conditions/
Conditions_File = 'conditions_80.xml'
 
# Choose the numerical scheme you're using, IterativeFull or IterativeStaticCond
Scheme = 'IterativeStaticCond'
 
# Select the values of N_Z you wish to calibrate the model with
Consider_Modes = [80]
 
# Choose number of constant to fit to the serial model model, 1 or 2
Num_Constants = 2
 
# Do you wish to run the clearcomparison between the calibrated serial model prediction and the collected data.
# Set to false if your serial data was collected to a different core than the one you are calibrating for.
Compare_Serial = False
 
# Do you wish to run the parallel portion of the model
Parallel = True
 
# Choose the Parallelisation method for the model to adopt, Modal, Elemental, Hybrid_Socket or Hybrid_Node 
Parallelisation = 'Hybrid_Socket'
 
# Do you wish to run the comparison between the full model prediction and the collected data
Compare_Parallel = True
 
# Input number of nodes you are using (Can replace this with PBS_Job_Parse)
Num_Node = 1
 
#------------------------------------
# Generate Input Filename Locations
#------------------------------------
 
(Mesh_File, Input_Nektar_Max, Conditions, Loc_Serial_Timing_Files, Loc_Parallel_Timing_Files, Benchmark_PBS, MPI_Benchmark, Node_Map) = Filename_Generate(Mesh, Max_N_Z, Conditions_File)
 
#------------------------------------
# Generate Output Locations
#------------------------------------
 
output_path = 'Output/Figures/'
if os.path.exists(output_path):
    cmd_string_clear = 'rm -r Output/Figures/ \n'
    process = Popen([cmd_string_clear],shell=True, stdout=PIPE, stdin=PIPE)
    process.wait()
    os.mkdir(output_path)
    
if not os.path.exists(output_path):
    os.mkdir(output_path)
    
#------------------------------------
# Parse Max Modes Nektar Input
#------------------------------------
 
(Pressure, Velocity_1, Velocity_2, Velocity_3) = Parse_Nektar_CG_Benchmark_Output(Input_Nektar_Max)
 
#------------------------------------
# Pharse Serial Nektar Inputs
#------------------------------------
 
Nektar_Serial_Elements = Find_Nektar_Elements(Mesh_File)
 
(Nektar_Modes, Timing_Files) = Find_Nektar_Files(Loc_Serial_Timing_Files)
 
Timings = {}
for i in range(0, len(Timing_Files)):
    Timings[str(Nektar_Modes[i])] = Parse_Nektar_Output(Loc_Serial_Timing_Files + Timing_Files[i])
 
#------------------------------------
# Pharse Condition Inputs
#------------------------------------
 
(Num_Modes, P, Error, Message) = Find_Conditions(Conditions)
 
# Print error to file if needed
if (Error is False):
    Primary_Error_Out(Message)
    quit()
 
#------------------------------------
# Fit Serial Model
#------------------------------------
 
# Fit the model to the supplied data and return the FLOPs
Fit = Run_Serial_Fit(Compare_Serial, Consider_Modes, Num_Constants, P, Nektar_Serial_Elements, Nektar_Modes, Timings, Pressure, Velocity_1, Velocity_2, Velocity_3, 'IterativeStaticCond')
 
# Stop here if we do not wish to run the parallel model.
if Parallel is False:
    quit()
 
#------------------------------------
# Pharse Hardware Inputs
#------------------------------------
 
(Num_Core_Per_Node, Num_Core_Per_Socket, Num_Sock_Per_Node, Error, Message) = Find_Hardware(Node_Map)
 
# Print error to file if needed
if (Error is False):
    Primary_Error_Out(Message)
    quit()
 
# Calculate PROC_TOT using outputs of the PBS_Pharse and Find_Hardware functions
PROC_TOT = Num_Core_Per_Node * Num_Node
 
# #------------------------------------
# # Pharse Communication Inputs
# #------------------------------------
 
(PROC_BENCHMARK, Error, Message) = PBS_Benchmark_Parse(Benchmark_PBS)
 
# Print error to file if needed
if (Error is False):
    Primary_Error_Out(Message)
    quit()
 
(BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core) = Parse_Benchmark(MPI_Benchmark, PROC_BENCHMARK, Num_Core_Per_Socket, Num_Sock_Per_Node)
 
print(BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core)
 
#------------------------------------
# Error check all inputs
#------------------------------------
 
# Error check the inputs
(Error, Message) = Error_Check_Proc_Input(PROC_TOT, Num_Core_Per_Socket, Num_Sock_Per_Node, Num_Modes)
 
# Print error to file if needed
if (Error is False):
    Primary_Error_Out(Message)
    quit()
 
(Error, Message) = Error_Check_Comm_Input(BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core)
 
# Print error to file if needed
if (Error is False):
    Primary_Error_Out(Message)
    quit()
 
(PROC_Z, PROC_XY, Total) = 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)
 
if Compare_Parallel is False:
    quit()
 
Run_Parallel_Comparison(Loc_Parallel_Timing_Files, Parallelisation, PROC_Z, PROC_XY, Total)
 
#------------------------------------
# Main Program End
#------------------------------------