Parallelization of the Phase Field Model - Revision history

Yanmingw at 05:31, 1 April 2015

2015-04-01T05:31:47Z

← Older revision		Revision as of 05:31, 1 April 2015
Line 137:		Line 137:

	== Summary ==		== Summary ==
	From the above test cases, we can find the CUDA code gives the largest speedup factor of ~~around~~ 40. ~~The~~ MPI code gives a speedup factor of around 14, but the code can be accelerated further with more nodes. In addition, for simulations with extreme large size, MPI is expected to be the better solution, since memory may become an issue for CUDA code. Though OpenMP code doesn't obtain a very large speedup factor (the speedup factor of OpenMP is about 4), it is very easy to implement and can be applied to ~~your~~ PC with a reasonable acceleration.		From the above test cases, we can find the CUDA code gives the largest speedup factor, which is over 40. In comparison, the MPI code with 32 cores gives a speedup factor of around 14, but the code can be accelerated further with more nodes. In addition, for simulations with extreme large size, MPI is expected to be the better solution, since memory may become an issue for the CUDA code. Though OpenMP code doesn't obtain a very large speedup factor (the speedup factor of OpenMP is about 4), it is very easy to implement and can be applied to a personal desktop or laptop with a reasonable acceleration.

Yanmingw at 05:29, 1 April 2015

2015-04-01T05:29:47Z

← Older revision		Revision as of 05:29, 1 April 2015
Line 135:		Line 135:

	The time cost is 60.879 s.		The time cost is 60.879 s.

			== Summary ==
			From the above test cases, we can find the CUDA code gives the largest speedup factor of around 40. The MPI code gives a speedup factor of around 14, but the code can be accelerated further with more nodes. In addition, for simulations with extreme large size, MPI is expected to be the better solution, since memory may become an issue for CUDA code. Though OpenMP code doesn't obtain a very large speedup factor (the speedup factor of OpenMP is about 4), it is very easy to implement and can be applied to your PC with a reasonable acceleration.

Yanmingw at 05:16, 1 April 2015

2015-04-01T05:16:37Z

← Older revision		Revision as of 05:16, 1 April 2015
Line 15:		Line 15:
	[[Image: Phasefield_flow_chart.jpg \| frame \| center]]		[[Image: Phasefield_flow_chart.jpg \| frame \| center]]

	Starting from the serial c++ code, parallelization is done with OpenMP, MPI, and CUDA three approaches. In the ~~following~~ ~~sections,~~ we ~~would~~ ~~like~~ to ~~show~~ ~~how~~ to ~~use~~ ~~these~~ ~~parallel~~ ~~codes~~ in ~~details~~.		Starting from the serial c++ code, parallelization is done with OpenMP, MPI, and CUDA three approaches. These parallel codes can be downloaded together with the MD++ package from the '''svn''' server. The following command will checkout the latest MD++ to your current directory.

			svn co https://micro.stanford.edu/svn/MD++/trunk/ ./

			After you have the MD++ package (with the revision later than r478), you may follow the below sections, in which we discussed how to compile and run these parallel codes with details.

	== OpenMP code ==		== OpenMP code ==

Yanmingw at 05:10, 1 April 2015

2015-04-01T05:10:43Z

← Older revision		Revision as of 05:10, 1 April 2015
Line 110:		Line 110:

	The time cost is 170.368100 s		The time cost is 170.368100 s

			=== CUDA code ===
			Assuming the CUDA code has been compiled on Sherlock, to run the simulation interactively, we may need to reserve one GPU first by typing the command,

			salloc -N 1 -p gpu --qos=gpu --gres=gpu:1 --constraint="k20x"

			This reserves us the K20X GPU. Next to run the phase field simulation with CUDA, you may enter the following command under the MD++ home folder.

			srun bin/phasefield_sherlock scripts/work/phasefield/pf3d_test.tcl 3 1

			One thing should be mentioned that “model_type = 20” should be specified to call the CUDA multi-phase field function in the input script. For single phase field function, model_type = 10.

			The output for the first step should be like:
			curstep = 0 F = 3.556137471188e+05 Fraw = 3.556137471188e+05 G = 3.160552999005e+01 timestep = 3.16e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=0.0943 M02=0.0443 COM_x=-0.998 COM_y=-0.998

			The output for the step 200 should be like:
			curstep = 200 F = 3.438633096736e+05 Fraw = 3.440320815069e+05 G = 2.139663658787e+01 timestep = 4.67e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=-11.2 M02=-11.2 COM_x=-0.998 COM_y=-0.998

			The time cost is 60.879 s.

Yanmingw at 05:09, 1 April 2015

2015-04-01T05:09:52Z

← Older revision		Revision as of 05:09, 1 April 2015
Line 93:		Line 93:

	The time cost is 11m2.548s.		The time cost is 11m2.548s.

			=== MPI code ===
			The MPI code can be run interactively by the command

			mpirun –np 32 bin/phasefield_mc2_mpi scripts/work/phasefield/pf3d_test.tcl 2 1

			The above command runs the job with 32 CPUS, which should be consistent with the number of processors pre-set in src/phasefield.cpp.

			The output for the first step should be like:
			curstep = 0 F = 3.556137471184e+05 Fraw = 3.556137471184e+05 G = 3.160552999005e+01 timestep = 3.16e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=0.0943 M02=0.0443 COM_x=-0.998 COM_y=-0.998

			The output for the step 200 should be like:
			curstep = 200 F = 3.438630312383e+05 Fraw = 3.440320588185e+05 G = 2.139589914093e+01 timestep = 4.67e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=-11.2 M02=-11.2 COM_x=-0.998 COM_y=-0.998

			The time cost is 170.368100 s

Yanmingw at 05:09, 1 April 2015

2015-04-01T05:09:18Z

← Older revision		Revision as of 05:09, 1 April 2015
Line 78:		Line 78:

	The time cost is 42m26.627s.		The time cost is 42m26.627s.

			=== OpenMP code ===
			Under the MD++ home folder, the following command is used to run the phase field simulation on MC2.

			bin/phasefield_mc2_omp scripts/work/phasefield/pf3d_test.tcl 1 1

			The output for the first step should be like:
			curstep = 0 F = 3.556137471166e+05 Fraw = 3.556137471166e+05 G = 3.160552999005e+01 timestep = 3.16e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=0.0943 M02=0.0443 COM_x=-0.998 COM_y=-0.998

			The output for the step 200 should be like:
			curstep = 200 F = 3.438630312384e+05 Fraw = 3.440320588185e+05 G = 2.139589914093e+01 timestep = 4.67e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=-11.2 M02=-11.2 COM_x=-0.998 COM_y=-0.998

			The time cost is 11m2.548s.

Yanmingw at 05:08, 1 April 2015

2015-04-01T05:08:40Z

← Older revision		Revision as of 05:08, 1 April 2015
Line 60:		Line 60:
	== Test cases ==		== Test cases ==
	We wrote a tcl input script [[media:Pf3d_test.tcl.txt \| pf3d_test.tcl ]] for code validation and performance evaluation. The initial configuration is set to a spherical liquid droplet at the solid-vapor interface with a box size of 200x200x200. 200 steps’ simulation is run with dynamics_type = 8 (constrain the liquid volume and the droplet’s center of mass position in both x and y directions).		We wrote a tcl input script [[media:Pf3d_test.tcl.txt \| pf3d_test.tcl ]] for code validation and performance evaluation. The initial configuration is set to a spherical liquid droplet at the solid-vapor interface with a box size of 200x200x200. 200 steps’ simulation is run with dynamics_type = 8 (constrain the liquid volume and the droplet’s center of mass position in both x and y directions).

			=== Serial code ===

			The serial code can be considered as the reference state. To run the code,

			bin/phasefield_mc2 scripts/work/phasefield/pf3d_test.tcl 0 1

			The simulation results are printed on the screen. The followings are the output for the 1st step and the last step.

			The output for the first step should be like:
			curstep = 0 F = 3.556137471408e+05 Fraw = 3.556137471408e+05 G = 3.160552999005e+01 timestep = 3.16e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=0.0943 M02=0.0443 COM_x=-0.998 COM_y=-0.998

			The output for the step 200 should be like:
			curstep = 200 F = 3.438630312533e+05 Fraw = 3.440320588335e+05 G = 2.139589914093e+01 timestep = 4.67e-05
			rel_vol = ( 1.21, 42, 56.8)% M01=-11.2 M02=-11.2 COM_x=-0.998 COM_y=-0.998

			The time cost is 42m26.627s.

Yanmingw at 05:07, 1 April 2015

2015-04-01T05:07:03Z

← Older revision		Revision as of 05:07, 1 April 2015
Line 59:		Line 59:

	== Test cases ==		== Test cases ==
	We wrote a tcl input script [[~~media：Pf3d_test~~.tcl.txt \|pf3d_test.tcl ]] for code validation and performance evaluation. The initial configuration is set to a spherical liquid droplet at the solid-vapor interface with a box size of 200x200x200. 200 steps’ simulation is run with dynamics_type = 8 (constrain the liquid volume and the droplet’s center of mass position in both x and y directions).		We wrote a tcl input script [[media:Pf3d_test.tcl.txt \| pf3d_test.tcl ]] for code validation and performance evaluation. The initial configuration is set to a spherical liquid droplet at the solid-vapor interface with a box size of 200x200x200. 200 steps’ simulation is run with dynamics_type = 8 (constrain the liquid volume and the droplet’s center of mass position in both x and y directions).

Yanmingw at 05:06, 1 April 2015

2015-04-01T05:06:20Z

← Older revision		Revision as of 05:06, 1 April 2015
Line 19:		Line 19:
	== OpenMP code ==		== OpenMP code ==
	src/phasefield_omp.cpp contains our implementation of the OpenMP code. To compile the code, using cluster MC2 as an example, type		src/phasefield_omp.cpp contains our implementation of the OpenMP code. To compile the code, using cluster MC2 as an example, type



	make phasefield build=R SYS=mc2_omp		make phasefield build=R SYS=mc2_omp
Line 55:		Line 57:

	When the compilation is finished, the executable named as phasefield_sherlock will be created in the src/ folder.		When the compilation is finished, the executable named as phasefield_sherlock will be created in the src/ folder.

			== Test cases ==
			We wrote a tcl input script [[media：Pf3d_test.tcl.txt \|pf3d_test.tcl ]] for code validation and performance evaluation. The initial configuration is set to a spherical liquid droplet at the solid-vapor interface with a box size of 200x200x200. 200 steps’ simulation is run with dynamics_type = 8 (constrain the liquid volume and the droplet’s center of mass position in both x and y directions).

Yanmingw at 04:58, 1 April 2015

2015-04-01T04:58:05Z

← Older revision		Revision as of 04:58, 1 April 2015
Line 48:		Line 48:
	The CUDA code is implemented as src/phasefield_cuda.cu. The compilation of the code requires nvcc compiler. Here we use cluster Sherlock as an example. You may need to load the CUDA module first by entering		The CUDA code is implemented as src/phasefield_cuda.cu. The compilation of the code requires nvcc compiler. Here we use cluster Sherlock as an example. You may need to load the CUDA module first by entering

	module load cuda		module load cuda

	Then type the following command to compile the code,		Then type the following command to compile the code,

	make phasefield build=R SYS=sherlock CUDA=yes		make phasefield build=R SYS=sherlock CUDA=yes

	When the compilation is finished, the executable named as phasefield_sherlock will be created in the src/ folder.		When the compilation is finished, the executable named as phasefield_sherlock will be created in the src/ folder.