Speed comparison between PyMAPDL and APDL

[germa89]

We had lastly some interesting discussions about PyMAPDL speed, so I would like to put some data I collect about it. Hopefully we can get some interesting insights from the community about this interesting topic.

Please feel free to drop any comment or idea in the comment area below.

Test

In this test, we generate 10000 nodes, 10 times (iterations) by running the next input file:

/prep7
*do,i,1,10000
n,,i
*enddo

Configurations

The next configurations are considered.

• APDL (Single batch) is running all the iterations in the same MADPL process (all code in one input file).
• APDL (Multi Batch) is running a MAPDL process per each iteration.
• APDL (Single Input) is running a single MAPDL process where we input 10 times an /input file.
• APDL (Multi Input) is running a MAPDL process per each of the 10 iterations. Uses an /input file.
• PyMAPDL (Interactive) is running each command in the same PyMAPDL session.
• PyMAPDL (Interactive-No Output) is running each command in a muted PyMAPDL session.
• PyMADPL (Non-interactive) is running all the commands in a non_interactive content manager.
• PyMAPDL (Input) is just running an equivalent input file using /INPUT.

Results

APDL (Single batch) is the reference.
Number of averages is 10

	Test ranking	Time spent (s)	Relative (%)
1	APDL (Single Input)	0.426563	74.590
2	PyMAPDL (Input)	0.507334	88.714
3	APDL (Single batch)	0.571875	100.000
4	PyMADPL (Non-interactive)	0.608915	106.477
5	PyMAPDL (Interactive-No Output)	3.981701	696.254
6	APDL (Multi Input)	15.616893	2730.823
7	APDL (Multi Batch)	15.690191	2743.640
8	PyMAPDL (Interactive)	43.554374	7616.065

I have attached the python script I wrote so you can have a look, and hopefully, come up with some interesting thoughts and suggestions for improving this.

Discussion

As expected the fastest is the APDL (Single input) (little number of commands passed, and no python overhead).

Then you have the PyMAPDL (Input) method, but followed quite close by APDL (Single batch) and PyMAPDL (Non-interactive). This was expected.
Theoretically the APDL (Single batch) should offer the second best mark (no python overhead), however PyMAPDL (input) reduce much of the overhead by passing all the instructions in an /input file. It seems that using /input is much faster than passing the commands.
Because of how the non_interactive content manager is designed (it used /input!) its performance is also close to APDL (Single Input) plus a little Python overhead.

Then it comes the PyMAPDL (Interactive-No output). Definitely, omitting the ouput print can improve the performance, and it is recommended as long as it does not show conflicts (Some commands presents issues when muted. For example, get_value might not work correctly always).

Then we have the APDL (Multi *****), these commands account also for the time needed to start the MAPDL procees, so it is not the best comparison, but I thought it was interesting to include them here.

And lastly, PyMAPDL (Interactive) is the slowest one. This is understandable because there is Python overhead for each APDL command which is passed and executed.

Supporting files

Python script to recreate the numbers:

Show file source code

import os
import subprocess
import time
import numpy as np
from ansys.mapdl.core import launch_mapdl

t_ini = time.time()

###############################################################################
# Settings
number_iterations_loop = 10000
n_averages = 10

mapdl_dir = "C:\\Program Files\\ANSYS Inc\\v212\\ansys\\bin\\winx64\\MAPDL.EXE"
work_dir = "C:\\ansys_jobs\\speed"
python_dir = os.getcwd()
output = os.path.join(work_dir, "file.out")

###############################################################################
# Single Batch mode
#
# This does not account for the time used to start the MAPDL process, so it is
# a more fair comparison with PyMAPDL input results.

cmd_apdl = f"""
/clear,
t_total = 0 
n_averages = {n_averages}
*do,j,1,n_averages
*GET, t0, ACTIVE, 0, time, cpu
/prep7
*do,i,1,{number_iterations_loop}
n,,i
*enddo
*GET, t1, ACTIVE, 0, time, cpu
t_spent = t1-t0
t_total = t_total + t_spent
*enddo
t_average = t_total/n_averages
PARSAV,SCALAR,parameters,dat
"""

with open('input.dat', 'w') as fid:
    fid.write(cmd_apdl)

input_ = os.path.join(python_dir, "input.dat")
cmd = f'"{mapdl_dir}" -lch -p ansys -dis -mpi MSMPI -np 2 -dir "{work_dir}" -j file -i "{input_}" -o "{output}" -b -l en-us -s read'

pros = subprocess.Popen(cmd)
pros.wait()

with open(os.path.join(work_dir, 'parameters.dat'), 'r') as fid:
    text = fid.readlines()

line = [each for each in text if 'T_AVERAGE' in each][0]
t_batch_single = float(line.split(',')[-1].strip())

###############################################################################
# Multi Batch Mode
#
# This starts a MAPDL process for each iteration, so it should not be the
# fastest.

cmd_apdl_reduce = f"""/prep7
*do,i,1,{number_iterations_loop}
n,,i
*enddo"""

with open('input_reduced.dat', 'w') as fid:
    fid.write(cmd_apdl_reduce)

input_ = os.path.join(python_dir, "input_reduced.dat")

def multi_batch():

    cmd = f'"{mapdl_dir}" -lch -p ansys -dis -mpi MSMPI -np 2 -dir "{work_dir}" -j file -i "{input_}" -o "{output}" -b -l en-us -s read'

    t0 = time.time()
    pros = subprocess.Popen(cmd)
    pros.wait()
    t1 = time.time()
    return t1 - t0


t_batch_multiple = np.mean([multi_batch() for i in range(n_averages)])


###############################################################################
# Batch Single Input
#
# This starts a MAPDL process for each iteration, so it should not be the
# fastest.
# This mode is just to compare it with PyMAPDL input.
#

cmd_apdl_input = f"""
*GET, t0, ACTIVE, 0, time, cpu
n_averages = {n_averages}
*do,i,1,n_averages
/INPUT,{os.path.join(python_dir, "input_reduced.dat")},,,,
*enddo
*GET, t1, ACTIVE, 0, time, cpu
t_total = t1-t0
t_average2 = t_total/n_averages
PARSAV,SCALAR,parameters2,dat
"""

with open('batch_input.dat', 'w') as fid:
    fid.write(cmd_apdl_input)

input_ = os.path.join(python_dir, "batch_input.dat")

cmd = f'"{mapdl_dir}" -lch -p ansys -dis -mpi MSMPI -np 2 -dir "{work_dir}" -j file -i "{input_}" -o "{output}" -b -l en-us -s read'

pros = subprocess.Popen(cmd)
pros.wait()

with open(os.path.join(work_dir, 'parameters2.dat'), 'r') as fid:
    text = fid.readlines()

line = [each for each in text if 'T_AVERAGE2' in each][0]
t_batch_input_single = float(line.split(',')[-1].strip())

###############################################################################
# Batch Multi Input Mode
#
# This starts a MAPDL process for each iteration, so it should not be the
# fastest.
# This mode is just to compare it with PyMAPDL input.
#

cmd_apdl_input = f"""
/INPUT,{os.path.join(python_dir, "input_reduced.dat")},,,,
"""

with open('batch_input.dat', 'w') as fid:
    fid.write(cmd_apdl_input)

input_ = os.path.join(python_dir, "batch_input.dat")


def batch_input():

    cmd = f'"{mapdl_dir}" -lch -p ansys -dis -mpi MSMPI -np 2 -dir "{work_dir}" -j file -i "{input_}" -o "{output}" -b -l en-us -s read'

    t0 = time.time()
    pros = subprocess.Popen(cmd)
    pros.wait()
    t1 = time.time()
    return t1 - t0


t_batch_input_multiple = np.mean([batch_input() for i in range(n_averages)])

###############################################################################
# Pymapdl interactive
#
# Running PyMAPDL commands in an interactive way (one by one).

mapdl = launch_mapdl(additional_switches='-lch -p ansys -mpi MSMPI', nproc=2)


def interactive():
    mapdl.clear()
    t0 = time.time()
    mapdl.prep7()
    for i in range(number_iterations_loop):
        mapdl.n('', i)

    t1 = time.time()
    return t1 - t0


t_inter = np.mean([interactive() for each in range(n_averages)])

###############################################################################
# Pymapdl interactive No-output
#
# Same as interactive but, the output is muted.


def interactive_no_output():
    mapdl.mute = True
    mapdl.clear()
    t0 = time.time()
    mapdl.prep7()
    for i in range(number_iterations_loop):
        mapdl.n('', i)
    mapdl.mute = False
    t1 = time.time()
    return t1-t0


t_inter_no_out = np.mean([interactive_no_output() for i in range(n_averages)])

###############################################################################
# Pymapdl non_interactive
#
# Using ``non_interactive`` context manager.
#


def pymapdl_non_interactive():
    with mapdl.non_interactive:
        mapdl.clear()
        t0 = time.time()
        mapdl.prep7()
        for i in range(number_iterations_loop):
            mapdl.n('', i)

    t1 = time.time()
    return t1 - t0


t_non_inter = np.mean([pymapdl_non_interactive() for i in range(n_averages)])

###############################################################################
# Pymapdl input
#
# Using ``/INPUT`` to directly supply the commands to MAPDL process using
# PyMAPDL.


def pymapdl_input():
    t0 = time.time()
    mapdl.input(os.path.join(os.getcwd(), 'input_reduced.dat'))
    t1 = time.time()
    return t1 - t0


t_input = np.mean([pymapdl_input() for i in range(n_averages)])

###############################################################################
# Results
data = {
    'APDL (Single batch)': t_batch_single,
    'APDL (Multi Batch)': t_batch_multiple,
    'APDL (Single Input)': t_batch_input_single,
    'APDL (Multi Input)': t_batch_input_multiple,
    'PyMAPDL (Interactive)': t_inter,
    'PyMAPDL (Interactive-No Output)': t_inter_no_out,
    'PyMADPL (Non-interactive)': t_non_inter,
    'PyMAPDL (Input)': t_input
}

with open('solution.sol', 'w') as fid:
    for each_key, each_item in data.items():
        fid.write(f"{each_key}:{each_item}\n")

# sorted(data, key=data.__getitem__)

print("=== Results ===")
print("APDL Real Batch is the reference.")
print(f"Number of averages is {n_averages}")
for each_test, each_time in data.items():
    print(f"{each_test.ljust(40)} - Time spent: {each_time:10.6f} s - Relative: {100*each_time/t_batch_single:10.3f} %")

mapdl.exit()

t_end = time.time()

print(f"\nTotal elapsed time: {t_end-t_ini} s\n=======")