Michael Thuné

Variation theory applied to students’ conceptions of computer programming

The present work has its focus on university-level engineering education students that do not intend to major in computer science but still have to take a mandatory programming course. Phenomenography and variation theory are applied to empirical data from a study of students’ conceptions of computer programming. A phenomenographic outcome space is presented, with five qualitatively different categories of description of students’ ways of seeing computer programming. Moreover, dimensions of variation related to these categories are identified. Based on this discussion it is suggested how to use patterns of variation in order to support students’ learning of computer programming. Finally, results from a pilot study demonstrate the successful application of two patterns of variation in a computer lab assignment.

PARTITIONING STRATEGIES FOR COMPOSITE GRIDS

Two different strategies are discussed, for the partitioning of composite grids, in the context of parallel computers of MIMD type with distributed memory. The two strategies are compared theoretically, with respect to arithmetic load balance and communication overhead. Moreover, the ability to handle dynamically changing grids is considered. Composite, structured grids are the natural choice for finite difference methods on complicated geometries, which can not be covered by a single, structured grid. A composite grid is a union of (in general curvilinear) structured grids. So called multi-block grids, frequently used, e.g., in aerodynamical computations, constitute a special case. The discussion in the present paper is valid also if the blocks are unstructured, and for hybrids such as dragon grids. Composite grids are more complicated to partition than single grids. The present paper points out the difficulties in detail, giving some quantification of the overhead that may result from a naive implementa...

Paper: Straightforward partitioning of composite grids for explicit difference methods

A straightforward partitioning strategy is analyzed for the case of explicit difference methods on composite grids. The computer is assumed to be of MIMD type with distributed memory. The amount of computational work at the boundary points is assumed to differ from that at the interior points. Theoretical estimates of the efficiency show that the straightforward strategy will be sufficiently efficient for problems with a relatively small work load at the boundary points, a modest number of processors, and close to square grids. For problems that are far from having these properties, a more sophisticated partitioning strategy is needed.

A Comparison of Partitioning Schemes for Blockwise Parallel SAMR Algorithms

This paper presents an experimental comparison of dynamic partitioning techniques for blockwise parallel structured adaptive mesh refinement applications. A new partitioning technique, G-MISP, is described. Policies for the automatic selection of partitioner based on application and system state are outlined. Adaptive methods for the numerical solution to partial differential equations yield highly advantageous ratios for cost/accuracy compared to methods based upon static uniform approximations. Distributed implementations offer the potential for accurate solution of physically realistic models of important applications. They also lead to interesting challenges in dynamic resource allocation, e.g. dynamic load balancing. The results show that G-MISP is preferable for communication dominated cases where the block graph has high granularity. Recommendations for appropriate partitioning techniques, given application and system state, are given. It was found that our classification model needs to be extended to accurately capture the behavior of the cases studied.

Object-oriented construction of parallel PDE solvers

An object-oriented approach is taken to the problem of formulating portable, easy-to-modify PDE solvers for realistic problems in three space dimensions. The resulting software library, Cogito, contains tools for writing programs to be executed on MIMD computers with distributed memory. Difference methods on composite, structured grids are supported. Most of the Cogito classes have been implemented in Fortran 77, in such a way that the object-oriented design is visible. With respect to parallel performance, these tools yield code that is comparable to parallel solvers written in plain Fortran 77. The resulting programs can be executed without modifications on a large number of multicomputer platforms, and also on serial computers.

Object-oriented software tools for the construction of preconditioners

In recent years, there has been considerable progress concerning preconditioned iterative methods for large and sparse systems of equations arising from the discretization of differential equations. Such methods are particularly attractive in the context of high-performance (parallel) computers. However, the implementation of a preconditioner is a nontrivial task. The focus of the present contribution is on a set of object-oriented software tools that support the construction of a family of preconditioners based on fast transforms. By combining objects of different classes, it is possible to conveniently construct any preconditioner within this family.

OpenMP versus MPI for PDE solvers based on regular sparse numerical operators

Two parallel programming models represented by OpenMP and MPI are compared for PDE solvers based on regular sparse numerical operators. As a typical representative of such an operator, a finite difference approximation of the Euler equations for fluid flow is considered. The comparison of programming models is made with regard to uniform memory access (UMA), non-uniform memory access (NUMA), and self-optimizing NUMA (NUMA-opt) computer architectures. By NUMA-opt, we mean NUMA systems extended with self-optimization algorithms, in order to reduce the non-uniformity of the memory access time. The main conclusions of the study are: (1) that OpenMP is a viable alternative to MPI on UMA and NUMA-opt architectures; (2) that OpenMP is not competitive on NUMA platforms, unless special care is taken to get an initial data placement that matches the algorithm; (3) that for OpenMP to be competitive in the NUMA-opt case, it is not necessary to extend the OpenMP model with additional data distribution directives, nor to include user-level access to the page migration library.

Automatic GKS stbility analysis

A new algorithm is presented for automatic stability investigation according to the theory of Gustafsson, Kreiss and Sundstrom. It is more efficient than approaches tried earlier, by taking advantage of the special structure of the system of algebraic equations whose solutions govern stability.The software system IBSTAB implements this algorithm, as well as procedures for checking von Neumann- and P-stability. IBSTAB combines symbolic formula manipulation and numerical routines. Furthermore, a user oriented problem description language is included. The software system is entirely FORTRAN based, the symbol manipulation parts being written in LISP, using the FORTRAN coded LISP-F3 interpreter.Results are presented from tests, in which IBSTAB was addressed to problems with known results. Also, a study is presented, in which IBSTAB was used as a tool in the development of stable numerical boundary conditions for a problem in fluid dynamics.

Design and usability of a PDE solver framework for curvilinear coordinates

Abstract An object-oriented PDE solver framework is a library of software components for numerical solution of partial differential equations, where each component is an object or a group of objects. Given such a framework, the construction of a particular PDE solver consists in selecting and combining suitable components. The present paper is focused on tengo [Ahlander K, Otto K. Software design for finite difference schemes based on index notation. Future Generation Comput Syst 2006;22:102–9], an object-oriented PDE solver framework for finite difference methods on structured grids, using tensor abstractions for convenient representation of numerical operators. Here, the design of tengo is extended to address curvilinear coordinates. These extensions to the tengo object model are the result of applying object-oriented analysis and design combined with feature modeling. The framework was implemented in Fortran 90/95, using standard techniques for emulating object-oriented constructs in that language. The new parts of the framework were assessed with respect to programming effort and execution time. It is shown that the programming effort required for construction and modification of PDE solvers on curvilinear grids is significantly reduced through the introduction of the new framework components. Moreover, for the test case of an underwater acoustics computation, there was no significant difference in execution time between the framework based code and a special purpose Fortran 90 code for the same application.

Parallel Structured Adaptive Mesh Refinement

Parallel structured adaptive mesh refinement is a technique for efficient utilization of computational resources. It reduces the computational effort and memory requirements needed for numerical simulation of complex phenomena, described by partial differential equations. Structured adaptive mesh refinement (SAMR) is applied in simulations where the domain is divided into logically rectangular patches, where each patch is discretized with a structured mesh. The purpose of adaptive mesh refinement is to automatically adapt the mesh to the resolution required to represent important features of the simulated phenomenon in different subdomains. In a parallel computing context, an important consequence of the adaptation is that the dynamically changing resolution leads to a dynamically changing work load, data volume, and communication pattern at run-time. This calls for dynamic load balancing and has implications for data placement as well as parallelization granularity. This chapter gives an overview of structured adaptive mesh refinement approaches. After a brief introductory survey of SAMR techniques and software packages, the main part of the chapter addresses various issues related to implementation of SAMR on parallel computers. In particular programming models, data placement and load balancing are discussed, for shared memory as well as distributed memory platforms. Various approaches and algorithms are presented. The appropriate choice of dynamic load balancing algorithm, data placement strategy, programming model, etc., depends on both the application state and the computer platform. There