| 1. |
|
|
| 2. |
|
|
| 3. |
- Fritzson, Peter, 1952-, et al.
(författare)
-
Modelica - A Strongly Typed System Specification Language for Safe Engineering Practices
- 2004
-
Ingår i: Proceedings of the SimSAFE Conference, Karlskoga, Sweden, June 15-17, 2004.
-
Konferensbidrag (övrigt vetenskapligt/konstnärligt)abstract
- Recent years have witnessed a significant growth of interest in modeling and simulation of engineering application systems. A key factor in this growth has been the development of efficient equation-based simulation languages, with Modelica as one of the prime examples. Such languages have been designed to allow automatic generation of efficient simulation code from declarative specifications. A major objective is to facilitate reuse and exchange of models, model libraries, and simulation specifications.The Modelica language and its associated support technologies have achieved considerable success through the development of domain libraries in a number of technical areas. By using domain-libraries complex simulation models can be built by aggregating and combining submodels and components from various physical domains.The concept of safe engineering practices has been one of the most important guidelines when designing Modelica. This made it natural to make Modelica a statically strongly typed language, which allows the compiler to check the consistency of a design before it is executed, in contrast to dynamically typed languages such as Matlab.The ability of static checking has also influenced the design of conditional equations and the ongoing the design of variant handling features in Modelica. Moreover, the language allows support for standardized physical units, thus enabling tools for unit checking of relationships and connections between interfaces. A third possible level of checking is through design rules within application-specific libraries, which can be enforced via assert statements. These properties taken together gives a good foundation for safe engineering practices, even though more work is needed to further increase the safety quality level.
|
|
| 4. |
- Fritzson, Peter, et al.
(författare)
-
The Open Source Modelica Project
- 2002
-
Ingår i: Proceedings from The 2nd International Modelica Conference was held March 18-19, 2002, Oberpfaffenhofen, Germany. - : Modelica Association. ; , s. 297-306
-
Konferensbidrag (refereegranskat)abstract
- The open source software movement has received enormous attention in recent years. It is often characterized as a fundamentally new way to develop software. This paper describes an effort to develop an open source Modelica environment to a large extent based on a formal specification of Modelica, coordinated by PELAB, Department of Computer and Information Science, Linköping University, Sweden. The current version of the system provides an efficient interactive computational environment for most of the expression, algorithm, and function parts of the Modelica language as well as an almost complete static semantics for Modelica 2.0.The longer-term goal is to provide reasonable simulation execution support, at least for less complex models, also for the equation part of Modelica which is the real essence of the language. People are invited to contribute to this open source project, e.g. to provide implementations of numerical algorithms as Modelica functions, add-on tools to the environment, or contributions to compiler itself. The source code of the tool components of the open source Modelica environment is available under the Gnu Public License, GPL. The library components are available under the same conditions as the standard Modelica library. The system currently runs under Microsoft Windows, Linux, and Sun Sparc Solaris. A benchmark example of running a simplex algorithm shows that the performance of the current system is close to the performance of handwritten C code for the same algorithm.
|
|
| 5. |
- Aronsson, Peter, et al.
(författare)
-
A Task Merging Technique for Parallelization of Modelica Models
- 2005
-
Ingår i: 4th International Modelica Conference. ; , s. -128
-
Konferensbidrag (refereegranskat)abstract
- This paper presents improvements on techniques of merging tasks in task graphs generated in the ModPar automatic parallelization module of the OpenModelica compiler. Automatic parallelization is performed on Modelica models by building data dependency graphs called task graphs from the model equations. To handle large task graphs with fine granularity, i.e. low ratio of execution and communication cost, the tasks are merged. This is done by using a graph rewrite system(GRS), which is a set of graph transformation rules applied on the task graph. In this paper we have solved the confluence problem of the task merging system by giving priorities to the merge rules. A GRS is confluent if the application order of the graph transformations does not matter, i.e. the same result is gained regardless of application order. We also present a Modelica model suited for automatic parallelization and show results on this using the ModPar module in the OpenModelica compiler.
|
|
| 6. |
|
|
| 7. |
- Aronsson, Peter, 1974-
(författare)
-
Automatic Parallelization of Equation-Based Simulation Programs
- 2006
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Modern equation-based object-oriented modeling languages which have emerged during the past decades make it easier to build models of large and complex systems. The increasing size and complexity of modeled systems requires high performance execution of the simulation code derived from such models. More efficient compilation and code optimization techniques can help to some extent. However, a number of heavy-duty simulation applications require the use of high performance parallel computers in order to obtain acceptable execution times. Unfortunately, the possible additional performance offered by parallel computer architectures requires the simulation program to be expressed in a way that makes the potential parallelism accessible to the parallel computer. Manual parallelization of computer programs is generally a tedious and error prone process. Therefore, it would be very attractive to achieve automatic parallelization of simulation programs.This thesis presents solutions to the research problem of finding practically usable methods for automatic parallelization of simulation codes produced from models in typical equationbased object-oriented languages. The methods have been implemented in a tool to automatically translate models in the Modelica modeling language to parallel codes which can be efficiently executed on parallel computers. The tool has been evaluated on several application models. The research problem includes the problem of how to extract a sufficient amount of parallelism from equations represented in the form of a data dependency graph (task graph), requiring analysis of the code at a level as detailed as individual expressions. Moreover, efficient clustering algorithms for building clusters of tasks from the task graph are also required. One of the major contributions of this thesis work is a new approach for merging fine-grained tasks by using a graph rewrite system. Results from using this method show that it is efficient in merging task graphs, thereby decreasing their size, while still retaining a reasonable amount of parallelism. Moreover, the new task-merging approach is generally applicable to programs which can be represented as static (or almost static) task graphs, not only to code from equation-based models.An early prototype called DSBPart was developed to perform parallelization of codes produced by the Dymola tool. The final research prototype is the ModPar tool which is part of the OpenModelica framework. Results from using the DSBpart and ModPar tools show that the amount of parallelism of complex models varies substantially between different application models, and in some cases can produce reasonable speedups. Also, different optimization techniques used on the system of equations from a model affect the amount of parallelism of the model and thus influence how much is gained by parallelization.
|
|
| 8. |
- Aronsson, Peter
(författare)
-
Automatic Parallelization of Simulation Code from Equation Based Simulation Languages
- 2002
-
Licentiatavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Modern state-of-the-art equation based object oriented modeling languages such as Modelica have enabled easy modeling of large and complex physical systems. When such complex models are to be simulated, simulation tools typically perform a number of optimizations on the underlying set of equations in the modeled system, with the goal of gaining better simulation performance by decreasing the equation system size and complexity. The tools then typically generate efficient code to obtain fast execution of the simulations. However, with increasing complexity of modeled systems the number of equations and variables are increasing. Therefore, to be able to simulate these large complex systems in an efficient way parallel computing can be exploited.This thesis presents the work of building an automatic parallelization tool that produces an efficient parallel version of the simulation code by building a data dependency graph (task graph) from the simulation code and applying efficient scheduling and clustering algorithms on the task graph. Various scheduling and clustering algorithms, adapted for the requirements from this type of simulation code, have been implemented and evaluated. The scheduling and clustering algorithms presented and evaluated can also be used for functional dataflow languages in general, since the algorithms work on a task graph with dataflow edges between nodes.Results are given in form of speedup measurements and task graph statistics produced by the tool. The conclusion drawn is that some of the algorithms investigated and adapted in this work give reasonable measured speedup results for some specific Modelica models, e.g. a model of a thermofluid pipe gave a speedup of about 2.5 on 8 processors in a PC-cluster. However, future work lies in finding a good algorithm that works well in general.
|
|
| 9. |
|
|
| 10. |
- Aronsson, Peter, et al.
(författare)
-
Parallel Code Generation in MathModelica / An Object Oriented Component Based Simulation Environment
- 2001
-
Ingår i: Proceedings of Workshop on Parallel/High Performance Object-Oriented Scientific Computing (POOSC’01).
-
Konferensbidrag (refereegranskat)abstract
- Modelica is an a-causal, equation based, object oriented modeling lan- guage for modeling and efficient simulation of large and complex multi domain systems. The Modelica language, with its strong software component model, makes it possible to use visual component programming, where large complex physical systems can be modeled and composed in a graphical way. One tool with support for both graphical modeling, textual programming and simulation is MathModelica. To deal with growing complexity of modeled systems in the Modelica language, the need for parallelization becomes increasingly important in order to keep sim- ulation time within reasonable limits. The first step in Modelica compilation results in an Ordinary Differential Equa- tion system or a Differential Algebraic Equation system, depending on the spe- cific Modelica model. The Modelica compiler typically performs optimizations on this system of equations to reduce its size. The optimized code consists of simple arithmetic operations, assignments, and function calls. This paper presents an automatic parallelization tool that builds a task graph from the optimized sequential code produced by a commercial Modelica compiler. Var- ious scheduling algorithms have been implemented, as well as specific enhance- ments to cluster nodes for better computation/communication tradeoff. Finally, the tool generates simulation code, in a master-slave fashion, using MPI.
|
|
