skip to main content
OSTI.GOV title logo U.S. Department of Energy
Office of Scientific and Technical Information

Title: Parallel Execution of Functional Mock-up Units in Buildings Modeling

Abstract

A Functional Mock-up Interface (FMI) defines a standardized interface to be used in computer simulations to develop complex cyber-physical systems. FMI implementation by a software modeling tool enables the creation of a simulation model that can be interconnected, or the creation of a software library called a Functional Mock-up Unit (FMU). This report describes an FMU wrapper implementation that imports FMUs into a C++ environment and uses an Euler solver that executes FMUs in parallel using Open Multi-Processing (OpenMP). The purpose of this report is to elucidate the runtime performance of the solver when a multi-component system is imported as a single FMU (for the whole system) or as multiple FMUs (for different groups of components as sub-systems). This performance comparison is conducted using two test cases: (1) a simple, multi-tank problem; and (2) a more realistic use case based on the Modelica Buildings Library. In both test cases, the performance gains are promising when each FMU consists of a large number of states and state events that are wrapped in a single FMU. Load balancing is demonstrated to be a critical factor in speeding up parallel execution of multiple FMUs.

Authors:
 [1];  [1];  [1]
  1. Oak Ridge National Lab. (ORNL), Oak Ridge, TN (United States)
Publication Date:
Research Org.:
Oak Ridge National Lab. (ORNL), Oak Ridge, TN (United States)
Sponsoring Org.:
USDOE Office of Energy Efficiency and Renewable Energy (EERE)
OSTI Identifier:
1257905
Report Number(s):
ORNL/TM-2016/173
BT0305000; CEBT105
DOE Contract Number:
AC05-00OR22725
Resource Type:
Technical Report
Country of Publication:
United States
Language:
English
Subject:
97 MATHEMATICS AND COMPUTING; Modelica; FMI; OpenMP; Dymola; Buildings Modeling

Citation Formats

Ozmen, Ozgur, Nutaro, James J., and New, Joshua Ryan. Parallel Execution of Functional Mock-up Units in Buildings Modeling. United States: N. p., 2016. Web. doi:10.2172/1257905.
Ozmen, Ozgur, Nutaro, James J., & New, Joshua Ryan. Parallel Execution of Functional Mock-up Units in Buildings Modeling. United States. doi:10.2172/1257905.
Ozmen, Ozgur, Nutaro, James J., and New, Joshua Ryan. 2016. "Parallel Execution of Functional Mock-up Units in Buildings Modeling". United States. doi:10.2172/1257905. https://www.osti.gov/servlets/purl/1257905.
@article{osti_1257905,
title = {Parallel Execution of Functional Mock-up Units in Buildings Modeling},
author = {Ozmen, Ozgur and Nutaro, James J. and New, Joshua Ryan},
abstractNote = {A Functional Mock-up Interface (FMI) defines a standardized interface to be used in computer simulations to develop complex cyber-physical systems. FMI implementation by a software modeling tool enables the creation of a simulation model that can be interconnected, or the creation of a software library called a Functional Mock-up Unit (FMU). This report describes an FMU wrapper implementation that imports FMUs into a C++ environment and uses an Euler solver that executes FMUs in parallel using Open Multi-Processing (OpenMP). The purpose of this report is to elucidate the runtime performance of the solver when a multi-component system is imported as a single FMU (for the whole system) or as multiple FMUs (for different groups of components as sub-systems). This performance comparison is conducted using two test cases: (1) a simple, multi-tank problem; and (2) a more realistic use case based on the Modelica Buildings Library. In both test cases, the performance gains are promising when each FMU consists of a large number of states and state events that are wrapped in a single FMU. Load balancing is demonstrated to be a critical factor in speeding up parallel execution of multiple FMUs.},
doi = {10.2172/1257905},
journal = {},
number = ,
volume = ,
place = {United States},
year = 2016,
month = 6
}

Technical Report:

Save / Share:
  • The research allows more effective model building. By allowing researchers to fit complex models to large datasets in a scalable manner, our algorithms and software enable more effective scientific research. In the new area of “big data,” it is often necessary to fit “big models” to adjust for systematic differences between sample and population. For this task, scalable and efficient model-fitting tools are needed, and these have been achieved with our new Hamiltonian Monte Carlo algorithm, the no-U-turn sampler, and our new C++ program, Stan. In layman’s terms, our research enables researchers to create improved mathematical modes for large andmore » complex systems.« less
  • This research supported the activities of 20 researchers during their visit to ICASE; as a result, 10 papers have appeared on issues related to parallel computation including such titles as Reordering computations for parallel execution, Multiprocessor L/U decomposition with controlled fill-in, and Analysis of a parallelized nonlinear elliptic boundary-value problem solver with applications to reacting flows. This reprint shows how to reorder the computations in the SOR algorithm to maintain the same asymptotic rate of convergence as the row-wise ordering and to obtain parallelism at different levels. A parallel program is written to illustrate these ideas and actual machines formore » implementation of this program are discussed.« less
  • The problem of exploiting the parallelism available in a program to efficiently employ the resources of the target machine is addressed. The problem is discussed in the context of building a mapping compiler for a distributed memory parallel machine. The paper describes using execution models to drive the process of mapping a program in the most efficient way onto a particular machine. Through analysis of the execution models for several mapping techniques for one class of programs, we show that the selection of the best technique for a particular program instance can make a significant difference in performance. On themore » other hand, the results of benchmarks from an implementation of a mapping compiler show that our execution models are accurate enough to select the best mapping technique for a given program.« less
  • The authors consider LU factorization of dense matrices, and develop analytical models for execution on MIMD local memory systems. Both broadcast and nearest neighbor communication models are studied by quantifying computation, communication, and idle times. The performance modelling is validated through experimental results on a transputer array. The authors implemented three variants of LU factorization on a unidirectional ring: nearest neighbor communications with non-overlapped as well as overlapped communications, and broadcasting with pipelined data transfer. It has been found that broadcasting falls in between non-overlapped and overlapped nearest neighbor communications.
  • Existing parallel architectures are constructed monolithically, with no well defined boundaries separating model and machine issues. This makes it difficult to evaluate the effect of a single component of an architecture, or compare it with the corresponding components of other architectures. Machine hardware is specialized to support a single programming model, even though similar but more general mechanisms could support a variety of models. Often details of an implementation become visible in the programming environment, restricting future implementation improvements because of compatibility. The lack of an interface between model and machine issues also complicates the translation of a machine improvementmore » into a performance improvement for model applications. This thesis defines Pi, a parallel architecture interface that separates model and machine issues, allowing them to be addressed independently. This provides greater flexibility for both the model and machine builder. Pi addresses a set of common parallel model requirements including low latency communication, fast task switching, low cost synchronization, efficient storage management, the ability to exploit locality, and efficient support for sequential code. Since Pi provides generic parallel operations, it can efficiently support for sequential code. Since Pi provides generic parallel operations, it can efficiently support many parallel programming models including hybrids of existing models. Pi also forms a basis of comparison for architectural components.« less