Julia is a relatively new computer language that aims to reduce the challenge for mathmodelers to develop fast computer tools and simulations. It potentially combines the ease-of-coding feature of scripting languages (like Python) with the performance of compiled languages (like C++). A key question for Julia application to the simulation domain is, Can Julia, with its obvious coding simplicity, provide runtime speeds comparable to conventional compiled languages for flight simulation? A unique combination of existing elements can be employed to address the previous question: Extensively documented object-oriented simulation architecture, Industry standard rocket flight simulation, Separate versions (C++, Java, and Python) already benchmarked

Sells, Ray

English

NASA Technical Reports Server

1IEEE Aerospace Conference, Big Sky, Montana, 12 March 2020
200114
Julia Programming Language Benchmark Using a Flight Simulation
Ray Sells
EV42/Guidance, Navigation, and Mission Analysis 
DESE Research, Inc./ESSCA
NASA-MSFC 4600-5119
256-961-4619
harold.r.sells@nasa.gov
https://ntrs.nasa.gov/search.jsp?R=20200001733 2020-03-28T19:08:29+00:00Z
2Overview
200114
• Julia is a relatively new computer language that aims to reduce the challenge for math-
modelers to develop fast computer tools and simulations. It potentially combines the 
ease-of-coding feature of scripting languages (like Python) with the performance of 
compiled languages (like C++). 
• A key question for Julia application to the simulation domain is, “Can Julia, with its obvious 
coding simplicity, provide runtime speeds comparable to conventional compiled languages 
for flight simulation?”
• A unique combination of existing elements can be employed to address the previous 
question
• Extensively documented object-oriented simulation architecture
• Industry standard rocket flight simulation
• Separate versions (C++, Java, and Python) already benchmarked 
3Julia Language Overview
Key Features:
• “Pythonic” syntax
• Dynamically-typed
• Built-in REPL (read-evaluate-print-loop)
• JIT (just-in-time) compilation
• Built-in library support for multi-threading, multi-core, and distributed processing
• Direct calling of C and Fortran code without “glue” code
• Automatic garbage collection (i.e. memory leak control)
• Easy extension to multi-processing
Practical Considerations:
• Designed for technical computing (like MATLAB & Fortran)
• Free and open-source
• High-level and easy-to-learn (like MATLAB & Python)
• High-performance (like C, C++, and Fortran)
official logo
4Mini-Rocket Description
• Generate trajectory given missile aerodynamic, mass, and 
propulsion parameters
• Generate family of trajectories (off-line) for higher-level 
system simulations or system time-line studies
• In-line missile (offensive or defensive) model for 
engagement simulations
• In-line missile dynamics model for HWIL
• Tool for quickly examining different guidance laws
• Tool for mapping battlespace engagement constraints
• Trajectory reconstruction/flight characteristics estimation
PAST APPLICATIONS:
DESCRIPTION:
EXTENSIVE LEGACY OF APPLICATION (partial list)
Strategic
• Endo-interceptors (HEDI, ARROW, THAAD)
• Exo-interceptors (ERIS, GBI, E2I)
• Anti-Satellite boosters (KE-ASAT)
• Strategic Target Vehicles (STARS, ARES)
• Numerous booster survey studies
Tactical
• NLOS-PAM
• EAPS
• Future Missile
• HAPS
• Modular Missile Technology
• IDEEAS constructive simulation (embedded interceptor)
FEATURES:
• Very fast running with unique osculating-plane formulation without 
the overhead of rigid body equations-of-motion (runtime speed of a 
3-DOF with additional two degrees-of-freedom)
• Motion in three-dimensional space
• Two independent channels (pitch and yaw) for steering and 
guidance
• 1-d, 2-d, or 3-d table lookups to model aerodynamics and propulsion 
characteristics
• Capability to model angle-of-attack variations in lift and drag
• Constraints on lateral acceleration based on angle-of-attack and 
closed-loop airframe response time
• Detailed models for control and guidance subsystems not required
Very easy to configure five degree-of-freedom missile flyout
model that accurately generates trajectories in three-
dimensional space, including maneuver characteristics 
without 6DOF overhead
5Mini-Rocket Case for Benchmark
• 3-stage hypothetical rocket (to avoid SBU concerns)
• vertical launch with pitch-over
• rotating earth
• pre-programmed maneuver in pitch and yaw channels
• lift-off weight = 2500 kg
• flight time = 100 sec
• stage splits = 40, 75 at 2708, 6790 m/sec
• final velocity = 6574 m/sec at t = 100 sec
• Benchmark case replicated for all three languages: 
C++, Python, Java
Benchmark TrajectoryBenchmark Rocket
"CMD Plot"
0 20 40 60 80 100
time
0
1000
2000
3000
4000
5000
6000
7000
ve
l
vel
"CMD Plot"
0 20 40 60 80 100
time
69
72
75
78
81
84
87
90
ga
m
m
a_
d
gamma_d
"CMD Plot"
0 20 40 60 80 100
time
-50
-40
-30
-20
-10
0
10
ay
ay
az
• a case was chosen to illustrate 5DOF maneuver model 
(i.e. 6DOF minus roll)
• pitch-over (red)
• out-of-plane yaw (blue)
• start pitch over at 20 sec to 75 deg, then execute dual 
pitch/yaw  ~1g maneuvers for 15 sec
6Julia Mini-Rocket Coding Highlights – Object Oriented
MINI-ROCKET JULIA BUILD PROCESS
• Simulation components built incrementally starting with DE engine and 
support elements (tables, atm. model, stages, integrator (clock), …)
• Extensive experimentation with coding techniques and structures to leverage 
Julia features with emphasis on code readability and then timing
• Benchmark timing studies conducted with DE engine and table elements to 
understand optimum Julia coding practice for speed
• Multiple, independent 2nd order transfer functions ran in parallel to 
prototype different DE engine representations and numerical 
integrators
• Large-scale table lookup benchmarks conducted to optimize speed 
(without sacrificing readability)
• After much experimentation, Julia was ~1/2 as fast as equivalent C++ 
code for DE and table look-up benchmarks
DIFFERENTIAL EQUATION (DE) ENGINE (the “main” program) OBJECT-ORIENTED
• all simulation entities are a hierarchy of objects
• clock
• rocket
• rocket stages
• atmosphere model
• etc. down-the-hierarchy
• Differential Equation Engine orchestrates execution
TABLE OBJECT CREATION AND USAGE
7Lines-of-Code Comparison
C++ Java Python Julia4
DE Engine1 360 310 227 982
rocket model 830 753 596 613
vector utilities 533 524 351 03
table utilities 650 384 252 165
misc. utilities 104 153 64 82
TOTAL 2477 2124 1490 958
NOTES:
1. All models coded to same O-O simulation kernel architecture
Reference
Sells, H.R., A Code Architecture to Streamline the 
Missile Simulation Life Cycle
AIAA Modeling and Simulation Technologies Conference, 12 January 2017
2. Julia DE engine does not encompass full functionality for OSK train-of-objects built into other 
DEs.  This lack of functionality was not relevant for this study.
3. Julia built-in linear algebra functionality used
4. Julia characters-of-code would have been GREATLY reduced without specifying types (at cost 
of great speed penalty and code readability)
8Benchmark Results – Mini-Rocket1
• initial data file read not included in timing loop
• small amount of screen output redirected to buffered file (SSD)
• no explicit compiler optimization flags for C++ and Java
• all cases run on Windows 10, Dell Precision 7820, Wintel High Performance Dual Socket Engineering 
Workstation, Intel Xeon Gold 6130 CPU @ 2.10GHz (2 processors, 32 cores each) , normal single-thread 
processing used for these runs
References:
1. “Mini-Rocket User Guide”, U.S. Army Technical Report AMR-SS-07-27, online link https://apps.dtic.mil/docs/citations/ADA472173  
2. “C++ Model Developer”, U.S. Army Technical Report, U.S. Army Technical Report AMR-SG-05-12,  online link 
https://apps.dtic.mil/docs/citations/ADA433836
9Benchmark Plots – Mini-Rocket
• Nature of Just-In-Time (JIT) is 
evident for Java and Julia
• JIT compile on-the-fly is more 
efficient for large # runs (JIT 
compilation consumes less amount 
of total run time)
• Surprise #1:  Java as efficient (or 
better than C++) – previous 
experience was Java ~ 4x slower*
• Surprise #2:  Python much better 
than previous experience ~ 100x 
slower*
*my personal experience as well as 
generally-accepted independent 
benchmarks
10
Multi-Core Processing Benchmarks
• Julia has very easy-to-extend functionality for utilizing multiple cores.
• The Julia Distributed package adds functionality to extend the single execution thread used-to-now 
to multiple cores.
• All cases run on Dell Precision 7820, Wintel High Performance Dual Socket Engineering Workstation, 
Intel Xeon Gold 6130 CPU @ 2.10GHz (2 processors, 32 cores each)
NOTES:
1. 65 runs executed concurrently including the master process and its 64 worker processes.
2. All output turned off, except final report
3. More runs per core appears to reduce overhead of distributing runs
Wrap-Up
• Challenges still exist in providing the tools and environment for quickly and efficiently 
constructing dynamical system simulations that address every step in the missile & rocket 
simulation life cycle
• The potential contribution of Julia is to give “non-expert” coders (scripters) the ability to build 
high performance simulations
• Julia was well suited to coding the object-oriented structure in MR with an exceptional 
economy-of-code
• Julia execution speed was much faster than Python but still slower than C++ and Java
Path Forward
• The economy of Julia to express complex programming constructs makes it attractive as a 
simulation experiment “testbed” for prototyping any future simulation applications
• Although only touched upon in these results, parallel computing capability and its application 
to time-domain dynamic system simulations is especially compelling for further flight 
simulation research


Julia Programming Language Benchmark Using a Flight Simulation

Abstract

Similar works

Full text

Available Versions

NASA Technical Reports Server