Message Passing Interface Standard Research Articles

MPI collective communication through a single set of interfaces: A case for orthogonality

We present and discuss a unified view of and interface for collective communication in the MPI (Message-Passing Interface) standard that in a natural way exploits MPI’s orthogonality of concepts. We observe that the currently separate and different interfaces for sparse and global collective communication can be unified under the global collective communication interfaces, and at the same time lead to leaner and stronger support for stencil-like, sparse collective communication on Cartesian communicators. Our observations not only significantly reduce the number of concrete operation interfaces, but extend the functionality that can be supported by MPI while provisioning for possible future, much more wide-ranging functionality.We suggest to (re)define communicators as the sole carriers of the topological structure over processes that determines the semantics of the collective operations, and to limit the functions that can associate topological information with communicators to the functions for distributed graph topology and inter-communicator creation. As a consequence, one set of interfaces for collective communication operations (in blocking, non-blocking, and persistent variants) will suffice, thereby explicitly eliminating the MPI_Neighbor_ interfaces (in all variants) from the MPI standard. Topological structure will no longer be implied by Cartesian communicators, which in turn will have the sole role of naming processes in a (d-dimensional, Euclidean) geometric point-space. The geometric naming can be passed to the topology creating functions as part of the communicator, and guide process rank reordering and topological collective algorithm selection. We also explore ramifications of our proposal for one-sided communication.Concretely, at the price of only one essential, additional function, our suggestion eliminates 10 concrete collective function interfaces from MPI 3.1, and 15 from MPI 4.0, while providing vastly more optimization scope for the MPI library implementation. Interfaces for Cartesian communicators can likewise be simplified and/or eliminated from the MPI standard, as could the general active (post-start) synchronization mechanism for one-sided communication.

Efficient implementation of MPI-3 RMA over openFabrics interfaces

The Message Passing Interface (MPI) standard supports Remote Memory Access (RMA) operations, where a process can read or write memory of another process without requiring the target process to be involved in the communication. This enables new more efficient programming models.This paper describes the RMA design and implementation in MPICH-OFI, an MPICH-based open source implementation of the MPI standard that uses the OpenFabrics Interfaces* (OFI*) to communicate with the underlying network fabric. MPICH-OFI is based on a new communication layer called CH4, which was designed to achieve high performance by minimizing the runtime software overhead and by having an internal API that is well aligned with MPI functions. MPICH-OFI uses the OpenFabrics Interfaces (OFI), a lightweight communication framework to support modern high-speed interconnects. Thanks to CH4 and OFI, MPICH-OFI achieves low latency and high bandwidth for RMA operations. Our experimental results using microbenchmarks show that MPICH-OFI achieves more than 3x better put/get latency and bandwidth than MPICH CH3, 10% better latency than Open MPI and MVAPICH2, and more than 1.7x bandwidth than MVAPICH2 for small messages ( ≤ 4KB), on Intel® Omni-Path Architecture.

Towards high performance robotic computing

Embedding a robot with a companion computer is becoming a common practice nowadays. Such computer is installed with an operatingsystem, often a Linux distribution. Moreover, Graphic Processing Units (GPUs) can be embedded on a robot, giving it the capacity of performing complex on-board computing tasks while executing a mission. It seems that a next logical transition, consist of deploying a cluster of computers among embedded computing cards. With this approach, a multi-robot system can be set as a High Performance Computing (HPC) cluster. The advantages of such infrastructure are many, from providing higher computing power up to setting scalable multi-robot systems. While HPC has been always seen as a speeding-up tool, we believe that HPC in the world of robotics can do much more than simply accelerating the execution of complex computing tasks. In this paper, we introduce the novel concept of High Performance Robotic Computing — HPRC, an augmentation of the ideas behind traditional HPC to fit and enhance the world of robotics. As a proof of concept, we introduce novel HPC software developed to control the motion of a set of robots using the standard parallel MPI (Message Passing Interface) library. The parallel motion software includes two operation modes: Parallel motion to specific target and swarm-like behavior. Furthermore, the HPC software is virtually scalable to control any quantity of moving robots, including Unmanned Aerial Vehicles, Unmanned Ground Vehicles, etc.

Verification of MPI Java programs using software model checking

Development of concurrent software requires the programmer to be aware of non-determinism, data races, and deadlocks. MPI (message passing interface) is a popular standard for writing message oriented distributed applications. Some messages in MPI systems can be processed by one of the many machines and in many possible orders. This non-determinism can affect the result of an MPI application. The alternate results may or may not be correct. To verify MPI applications, we need to check all these possible orderings and use an application specific oracle to decide if these orderings give correct output. MPJ Express is an open source Java implementation of the MPI standard. We developed a Java based model of MPJ Express, where processes are modeled as threads, and which can run unmodified MPI Java programs on a single system. This enabled us to adapt the Java PathFinder explicit state software model checker (JPF) using a custom listener to verify our model running real MPI Java programs. We evaluated our approach using small examples where model checking revealed message orders that would result in incorrect system behavior.

Krylov subspace methods for the Dirac equation

The Lanczos algorithm is evaluated for solving the time-independent as well as the time-dependent Dirac equation with arbitrary electromagnetic fields. We demonstrate that the Lanczos algorithm can yield very precise eigenenergies and allows very precise time propagation of relativistic wave packets. The unboundedness of the Dirac Hamiltonian does not hinder the applicability of the Lanczos algorithm. As the Lanczos algorithm requires only matrix–vector products and inner products, which both can be efficiently parallelized, it is an ideal method for large-scale calculations. The excellent parallelization capabilities are demonstrated by a parallel implementation of the Dirac Lanczos propagator utilizing the Message Passing Interface standard. Program summaryProgram title: Dirac_LaczosCatalogue identifier: AEUY_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEUY_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 526428No. of bytes in distributed program, including test data, etc.: 2181729Distribution format: tar.gzProgramming language: C++11.Computer: Multi-core systems or cluster computers.Operating system: Any.Has the code been vectorized or parallelized?: Parallelized using MPI.RAM: Typically 10 megabyte to 1 gigabyte depending on the chosen problem sizeClassification: 2.7.External routines: Boost [1], LAPACK [2]Nature of problem:Solving the time-dependent Dirac equation in two spatial dimensionsSolution method:Lanczos propagatorRunning time:Depending on the problem size and computer hardware typically several minutes to several days

Optimization and parallelization of the thermal–hydraulic subchannel code CTF for high-fidelity multi-physics applications

This paper describes major improvements to the computational infrastructure of the CTF subchannel code so that full-core, pincell-resolved (i.e., one computational subchannel per real bundle flow channel) simulations can now be performed in much shorter run-times, either in stand-alone mode or as part of coupled-code multi-physics calculations. These improvements support the goals of the Department Of Energy Consortium for Advanced Simulation of Light Water Reactors (CASL) Energy Innovation Hub to develop high fidelity multi-physics simulation tools for nuclear energy design and analysis.A set of serial code optimizations—including fixing computational inefficiencies, optimizing the numerical approach, and making smarter data storage choices—are first described and shown to reduce both execution time and memory usage by about a factor of ten. Next, a “single program multiple data” parallelization strategy targeting distributed memory “multiple instruction multiple data” platforms utilizing domain decomposition is presented. In this approach, data communication between processors is accomplished by inserting standard Message-Passing Interface (MPI) calls at strategic points in the code. The domain decomposition approach implemented assigns one MPI process to each fuel assembly, with each domain being represented by its own CTF input file. The creation of CTF input files, both for serial and parallel runs, is also fully automated through use of a pressurized water reactor (PWR) pre-processor utility that uses a greatly simplified set of user input compared with the traditional CTF input.To run CTF in parallel, two additional libraries are currently needed: MPI, for inter-processor message passing, and the Parallel Extensible Toolkit for Scientific Computation (PETSc), which is used to solve the global pressure matrix in parallel. Results presented include a set of testing and verification calculations and performance tests assessing parallel scaling characteristics up to a full-core, pincell-resolved model of a PWR core containing 193 17×17 assemblies under hot full-power conditions. This model, representative of Watts Bar Unit 1 and containing about 56,000 pins, was modeled with roughly 59,000 subchannels, leading to about 2.8 million thermal–hydraulic control volumes in total. Results demonstrate that CTF can now perform full-core analysis of a PWR (not previously possible owing to excessively long runtimes and memory requirements) on the order of 20min. This new capability not only is useful to stand-alone CTF users, but also is being leveraged in support of coupled code multi-physics calculations being done in the CASL program.

Parallelization of nonuniform loops in supercomputers with distributed memory

A template algorithm for parallel execution of independent iterations of the repetitive loop on a multiprocessor computer with distributed memory is constructed. Regardless of the number of processors, the algorithm must provide efficient utilization of computing capacity under essentially different complexities of iterations and/or performance of processors. The interprocessor data communication and control of par� allel computations are assumed to be implemented using a standard messagepassing interface (MPI), which is widely used in such systems. Existing methods for the loop parallelization are analyzed and the correspond� ing efficiencies are empirically estimated for various models of iteration nonuniformity.

A Parallel Scenario Processing Algorithm in Environmental Decision Support Systems

The scenario analysis method is used widespread in environmental management fields. Massive scenarios used in the applications lead to huge computing workloads and time-consuming. A parallel computing algorithm based on the Message Passing Interface (MPI) standard was proposed to enhance the computing performance of scenario generating and calculating. By taking a river restoration planning problem as a case study, the proposed algorithm was applied in a decision support system and tested on a multi-core workstation. Experimental results show that when performed on a quad-core workstation, the algorithm reduced the execution time to a quarter of the former, with a stable speedup factor of 3.8 at different amounts of scenarios. It is indicated that the proposed algorithm is practical in environmental decision-making procedure, with special reference to the general scenario analysis method and other similar applications in the fields of energy and environment.

An extensible interface for QM/MM molecular dynamics simulations with AMBER.

We present an extensible interface between the AMBER molecular dynamics (MD) software package and electronic structure software packages for quantum mechanical (QM) and mixed QM and classical molecular mechanical (MM) MD simulations within both mechanical and electronic embedding schemes. With this interface, ab initio wave function theory and density functional theory methods, as available in the supported electronic structure software packages, become available for QM/MM MD simulations with AMBER. The interface has been written in a modular fashion that allows straight forward extensions to support additional QM software packages and can easily be ported to other MD software. Data exchange between the MD and QM software is implemented by means of files and system calls or the message passing interface standard. Based on extensive tests, default settings for the supported QM packages are provided such that energy is conserved for typical QM/MM MD simulations in the microcanonical ensemble. Results for the free energy of binding of calcium ions to aspartate in aqueous solution comparing semiempirical and density functional Hamiltonians are shown to demonstrate features of this interface.

Extending the scope of the Checkpoint‐on‐Failure protocol for forward recovery in standard MPI

SUMMARYMost predictions of exascale machines picture billion ways parallelism, encompassing not only millions of cores but also tens of thousands of nodes. Even considering extremely optimistic advances in hardware reliability, probabilistic amplification entails that failures will be unavoidable. Consequently, software fault tolerance is paramount to maintain future scientific productivity. Two major problems hinder ubiquitous adoption of fault tolerance techniques: (i) traditional checkpoint‐based approaches incur a steep overhead on failure free operations and (ii) the dominant programming paradigm for parallel applications (the message passing interface (MPI) Standard) offers extremely limited support of software‐level fault tolerance approaches. In this paper, we present an approach that relies exclusively on the features of a high quality implementation, as defined by the current MPI Standard, to enable advanced forward recovery techniques, without incurring the overhead of customary periodic checkpointing. With our approach, when failure strikes, applications regain control to make a checkpoint before quitting execution. This checkpoint is in reaction to the failure occurrence rather than periodic. This checkpoint is reloaded in a new MPI application, which restores a sane environment for the forward, application‐based recovery technique to repair the failure‐damaged dataset. The validity and performance of this approach are evaluated on large‐scale systems, using the QR factorization as an example. Published 2013. This article is a US Government work and is in the public domain in the USA.

Hybrid MPI-OpenMP Parallelization of Image Reconstruction

Perceptual coding should take full advantage of the results from human visual system (HVS) studies. In this paper, we exploit an image reconstruction algorithm, which can simply and reliably represent images using regional shape and texture information and effectually eliminate perceptual redundancy. But real-time application of the algorithm is limited due to its inherent complex and intensive computation. Therefore, we implement image reconstruction with a hybrid message passing interface (MPI) and OpenMP approach on the basis of a standard MPI implementation. Experimental results confirm our image reconstruction algorithm can get optimal restoration results. Compared with JPEG and JPEG2000 compression, this algorithm can not only get more coding gain but remain most information people care. Our hybrid MPI-OpenMP approach can significantly improve time performance of image reconstruction algorithm.

Parallel grid library for rapid and flexible simulation development

We present an easy to use and flexible grid library for developing highly scalable parallel simulations. The distributed cartesian cell-refinable grid (dccrg) supports adaptive mesh refinement and allows an arbitrary C++ class to be used as cell data. The amount of data in grid cells can vary both in space and time allowing dccrg to be used in very different types of simulations, for example in fluid and particle codes. Dccrg transfers the data between neighboring cells on different processes transparently and asynchronously allowing one to overlap computation and communication. This enables excellent scalability at least up to 32 k cores in magnetohydrodynamic tests depending on the problem and hardware. In the version of dccrg presented here part of the mesh metadata is replicated between MPI processes reducing the scalability of adaptive mesh refinement (AMR) to between 200 and 600 processes. Dccrg is free software that anyone can use, study and modify and is available at https://gitorious.org/dccrg. Users are also kindly requested to cite this work when publishing results obtained with dccrg. Program summaryProgram title: DCCRGCatalogue identifier: AEOM_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEOM_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU Lesser General Public License version 3No. of lines in distributed program, including test data, etc.: 54975No. of bytes in distributed program, including test data, etc.: 974015Distribution format: tar.gzProgramming language: C++.Computer: PC, cluster, supercomputer.Operating system: POSIX.The code has been parallelized using MPI and tested with 1–32768 processesRAM: 10 MB–10 GB per processClassification: 4.12, 4.14, 6.5, 19.3, 19.10, 20.External routines: MPI-2 [1], boost [2], Zoltan [3], sfc++ [4]Nature of problem:Grid library supporting arbitrary data in grid cells, parallel adaptive mesh refinement, transparent remote neighbor data updates and load balancing.Solution method:The simulation grid is represented by an adjacency list (graph) with vertices stored into a hash table and edges into contiguous arrays. Message Passing Interface standard is used for parallelization. Cell data is given as a template parameter when instantiating the grid.Restrictions:Logically cartesian grid.Running time:Running time depends on the hardware, problem and the solution method. Small problems can be solved in under a minute and very large problems can take weeks. The examples and tests provided with the package take less than about one minute using default options.In the version of dccrg presented here the speed of adaptive mesh refinement is at most of the order of 106 total created cells per second.

ES-MPICH2: A Message Passing Interface with Enhanced Security

An increasing number of commodity clusters are connected to each other by public networks, which have become a potential threat to security sensitive parallel applications running on the clusters. To address this security issue, we developed a Message Passing Interface (MPI) implementation to preserve confidentiality of messages communicated among nodes of clusters in an unsecured network. We focus on M PI rather than other protocols, because M PI is one of the most popular communication protocols for parallel computing on clusters. Our MPI implementation-called ES-MPICH2-was built based on MPICH2 developed by the Argonne National Laboratory. Like MPICH2, ES-MPICH2 aims at supporting a large variety of computation and communication platforms like commodity clusters and high-speed networks. We integrated encryption and decryption algorithms into the MPICH2 library with the standard MPI interface and; thus, data confidentiality of MPI applications can be readily preserved without a need to change the source codes of the MPI applications. MPI-application programmers can fully configure any confidentiality services in MPICHI2, because a secured configuration file in ES-MPICH2 offers the programmers flexibility in choosing any cryptographic schemes and keys seamlessly incorporated in ES-MPICH2. We used the Sandia Micro Benchmark and Intel MPI Benchmark suites to evaluate and compare the performance of ES-MPICH2 with the original MPICH2 version. Our experiments show that overhead incurred by the confidentiality services in ES-MPICH2 is marginal for small messages. The security overhead in ES-MPICH2 becomes more pronounced with larger messages. Our results also show that security overhead can be significantly reduced in ES-MPICH2 by high-performance clusters. The executable binaries and source code of the ES-MPICH2 implementation are freely available at http:// www.eng.auburn.edu/~xqin/software/es-mpich2/.

표준 모드를 지원하는 5Q MPI 하드웨어 유닛 설계

최근 모바일 장치의 사용의 증가와 복잡한 응용 프로그램의 사용이 증가하면서 MPSoC의 사용이 증가하고 있다. 이러한 MPSoC의 성능을 향상시키기 위해 프로세서의 수가 늘어나고 있는 추세이다. 다수의 프로세서 구조에서 장점이 있는 분산 메모리 구조의 효율적인 데이터 전달하기 위해서 표준 MPI를 이용한다. 표준 MPI는 소프트웨어로 제공되지만, 하드웨어로 구현하면 보다 높은 성능을 얻을 수 있다. 하드웨어로 구현된 MPI의 메시지 전송 방식으로 기존의 동기 방식(Synchronous Mode), 준비 방식(Ready Mode), 버퍼 방식(Buffered Mode)과 이 방식들을 혼합한 형태인 표준 방식(Standard Mode)가 있다. 본 논문에는 기존의 MPI 하드웨어 유닛에서 사용되던 구조에 작은 크기의 데이터를 선별하여 버퍼 방식으로 전송함으로써 전송율을 극대화 하였다. 기존의 구조에서 사용된 3개의 큐(Queue)는 그대로 같은 기능을 하고, 본 논문에서 추가된 2개의 큐(작은 준비 큐와 작은 요청 큐)을 추가하여 임계점보다 작은 크기의 데이터에 대한 처리와 저장을 담당하도록 하여 성능을 향상하였다. 제안된 구조에서 임계점을 32byte로 제한하였을 때 임계점 이하의 데이터에서 20%의 성능 개선 효과를 볼 수 있었다. The use of MPSoC has been increasing because of a rise of use of mobile devices and complex applications. For improving the performance of MPSoC, number of processor has been increasing. Standard MPI is used for efficiently sending data in distributed memory architecture that has advantage in multi processor. Standard In this paper, we propose a scalable distributed memory system with a low cost hardware message passing interface(MPI). The proposed architecture improves transfer rate with buffered send for small size packet. Three queues, Ready Queue, Request Queue, and Reservation Queue, work as previous architecture, and two queues, Small Ready Queue and Small Request Queue, are added to send small size packet. When the critical point is set 8 bytes, the proposed architecture takes more than 2 times the performance improvement in the data that below the critical point.

A Low-Cost Standard Mode MPI Hardware Unit for Embedded MPSoC

In this paper, we propose a novel low-cost Message Passing Interface (MPI) unit between processor nodes, which supports message passing in multiprocessor systems using distributed memory architecture. Our MPI unit operates in the standard mode - using the buffered mode for small amounts of data transaction and the synchronous mode for large amounts of data transaction. This results in increased performance by reducing the control message transmission time for the small amount of data. We verified the performance with a simulator designed based on SystemC. Additionally, we designed the MPI unit using VerilogHDL, and we synthesized it with a synopsys design compiler. The proposed standard mode MPI unit shows a high performance even though the size of the MPI unit occupies less than 1% of the whole chip. Thus, with respect to low-cost design and scalability, this MPI hardware unit is useful to increase overall performance of the embedded Multiprocessor System on a Chip (MPSoC).

A Parallel Geometric Multigrid Method for Finite Elements on Octree Meshes

In this article, we present a parallel geometric multigrid algorithm for solving variable-coefficient elliptic partial differential equations on the unit box (with Dirichlet or Neumann boundary conditions) using highly nonuniform, octree-based, conforming finite element discretizations. Our octrees are 2:1 balanced, that is, we allow no more than one octree-level difference between octants that share a face, edge, or vertex. We describe a parallel algorithm whose input is an arbitrary 2:1 balanced fine-grid octree and whose output is a set of coarser 2:1 balanced octrees that are used in the multigrid scheme. Also, we derive matrix-free schemes for the discretized finite element operators and the intergrid transfer operations. The overall scheme is second-order accurate for sufficiently smooth right-hand sides and material properties; its complexity for nearly uniform trees is $\mathcal{O}(\frac{N}{n_p}\log\frac{N}{n_p})+\mathcal{O}(n_p\log n_p)$, where $N$ is the number of octree nodes and $n_p$ is the number of processors. Our implementation uses the Message Passing Interface standard. We present numerical experiments for the Laplace and Navier (linear elasticity) operators that demonstrate the scalability of our method. Our largest run was a highly nonuniform, 8-billion-unknown, elasticity calculation using 32,000 processors on the Teragrid system, “Ranger,” at the Texas Advanced Computing Center. Our implementation is publically available in the Dendro library, which is built on top of the PETSc library from Argonne National Laboratory.

C++ components describing parallel domain decomposition and communication

Large-scale parallel codes require the data to be decomposed between the set of processes active in the computation. This data decomposition implies recurring communication schemes. The paper introduces generic template classes in C++ for describing the data decomposition. The aim is to store the data in arbitrary existent efficient sequential data structures. Each entry in the sequential data structure corresponds to an entry in the virtual global view of the container. Once the decomposition is setup the needed communication schemes can be created automatically and can be used to communicate values from containers of various types. Even containers with a varying number of values associated with an entry are possible. The framework abstracts the decomposition information and the communication in the client code from the eventual parallel paradigm choice. A prototype based on Message Passing Interface standard is presented. It relieves the user from specifying information that is already known at compile time.

Numerical solution of the linearized fixed gravimetric boundary-value problem

The fixed gravimetric boundary-value problem (FGBVP) represents an exterior oblique derivative problem for the Laplace equation. Terrestrial gravimetric measurements located by precise satellite positioning yield oblique derivative boundary conditions in the form of surface gravity disturbances. In this paper, we discuss the boundary element method (BEM) applied to the linearized FGBVP. In spite of previous BEM approaches in geodesy, we use the so-called direct BEM formulation, where a weak formulation is derived through the method of weighted residuals. The collocation technique with linear basis functions is applied for deriving the linear system of equations from the arising boundary integral equations. The nonstationary iterative biconjugate gradient stabilized method is used to solve the large-scale linear system of equations. The standard MPI (message passing interface) subroutines are implemented in order to perform parallel computations. The proposed approach gives a numerical solution at collocation points directly on the Earth’s surface (on a fixed boundary). Numerical experiments deal with (i) global gravity field modelling using synthetic data (surface gravity disturbances generated from a global geopotential model (GGM)) (ii) local gravity field modelling in Slovakia using observed gravity data. In order to extend computations, the memory requirements are reduced using elimination of the far-zone effects by incorporating GGM or a coarse global numerical solution obtained by BEM. Statistical characteristics of residuals between numerical solutions and GGM confirm the reliability of the approach and indicate accuracy of numerical solutions for the global models. A local refinement in Slovakia results in a local (national) quasigeoid model, which when compared with GPS-levelling data, does not make a large improvement on existing remove-restore-based models.

Hybrid MPI-OpenMP Programming for Parallel OSEM PET Reconstruction

To improve the parallel efficiency (PE) of the ordered-subsets expectation-maximization (OSEM) algorithm for three-dimensional (3-D) positron emission tomography (PET) image reconstruction, we focused on reducing the computational imbalance among parallel processes and interprocess data exchange time which were the dominant limiting factors of PE when a large number of networked compute nodes were used. As clusters with multiple processors on each compute node have become increasingly common, we have aimed to take advantage of the load-balancing mechanism and the inherently lower latency of shared memory threads across processors within a single node. We, therefore, implemented the OSEM algorithm with a hybrid message passing interface (MPI) and OpenMP approach on the basis of a standard MPI implementation. The contributing components to the total reconstruction time for the hybrid technique were quantified and compared to that using only MPI. The hybrid MPI-OpenMP technique achieved a consistent PE improvement of approximately 7% to 17% compared to the pure MPI approach on the same number of compute nodes. As clusters of larger shared-memory multiprocessor (SMP) machines continue to become more cost effective, we expect this hybrid MPI-OpenMP approach to be increasingly valuable

Aerospace Vehicle Trajectory Design and Optimization Within a Multi-Disciplinary Environment

A trajectory design and optimization tool named Mission is developed to operate within a multi-disciplinary analysis tool environment for conceptual design of aerospace vehicles. Mission possesses several features designed to facilitate its set-up and operation within the environment. It receives input via an Extensible Markup Language tagged data file. The tree structure of the tags reflects that of a branched and multi-segmented trajectory, aiding parsing and editing for set-up of data exchange within the environment. Mission uses Xerces, a public domain library, for parsing data files. In addition, it is linked to both gradient-based andgeneticalgorithm-basedoptimizers,allowingachoicedependingontheamountofapriori informationavailable.Whenlittleisknownaboutthecontrolvariables,aninitialguessoftheir histories may be forgone by initializing the optimization process with the genetic algorithm. Once a solution is approached, the gradient-based method is used. This strategy increases the robustness and autonomy of the trajectory tool operation within the multi-disciplinary environment. Finally, Mission’s trajectory integration process is coded for parallel execution via the Message Passing Interface standard. The resultant execution speed increase reduces the relative expense of operating Mission within the multi-disciplinary environment. The resultsofaCrewTransferVehicle“abortfromascent”problemarepresentedtodemonstrate and quantify Mission’s features.