Charles D. Norton

Expressing object-oriented concepts in Fortran 90

Fortran 90 is a modern, powerful language with features that support important new programming concepts, including those used in object-oriented programming. This paper briefly summarizes how to express the concepts of data encapsulation, function overloading, classes, objects, inheritance, and dynamic dispatching.

How to Express C++ Concepts in Fortran90

This paper summarizes techniques for emulating in Fortran90 the most important object-oriented concepts of C++c classes (including abstract data types, encapsulation and function overloading), inheritance and dynamic dispatching.

How to support inheritance and run-time polymorphism in Fortran 90

Fortran 90 does not support automatic inheritance and run-time polymorphism as language mechanisms. This paper discusses techniques for software emulation of inheritance and polymorphism in Fortran 90, which simplifies the implementation of an object-oriented programming style in Fortran 90.

Object-oriented parallel computation for plasma simulation

Object-oriented techniques promise to improve the software design and programming process by providing an application-oriented view of programming while facilitating modification and reuse. Since the software design crisis is particularly acute in parallel computation, these techniques have stirred the interest of the scientific parallel computing community. Large-scale applications of ever-growing complexity, particularly in the physical sciences and engineering, require parallel processing for efficiency. Since its introduction in the 1970s, Fortran 77 has been the language of choice to model these problems, due to its efficiency, its numerical stability, and the body of existing Fortran codes. However, the introduction of object-oriented languages provides new alternatives for parallel software development. Fortran 90 adds modern extensions (including object-oriented concepts) to the established methods of Fortran 77. Alternatively, object-oriented methodologies can be explored through languages such as C++, Eiffel, Smalltalk, and many others. Our selection among these required a language that was widespread and supported across multiple platforms (particularly supercomputers) with strong compiler optimizations. C++, while not a “pure” object-oriented language, was our choice, since it meets these criteria.

Highly parallel structured adaptive mesh refinement using parallel language-based approaches

Abstract Adaptive Mesh Refinement (AMR) calculations carried out on structured meshes play an exceedingly important role in several areas of science and engineering. This is so not just because AMR techniques allow us to carry out calculations very efficiently but also because they model very precisely the multi-scale fashion in which nature itself works. Many AMR applications are also amongst the most computationally intensive calculations undertaken making it necessary to use parallel supercomputers for their solution. While class library-based approaches are being attempted for parallel AMR we point out here that recent advances in the Fortran 90/95 standard and the OpenMP standard now make it possible to carry out highly parallel AMR calculations using language-based approaches. The language-based approaches offer several advantages over library-based approaches, the two principal ones being portability across parallel platforms and the best possible utilization of Distributed Shared Memory (DSM) hardware on machines that have such hardware. They also free up the applications scientist from being constrained by the static features of a class library. The choice of Fortran also ensures maximal reuse of pre-existing Fortran 77 applications and full Fortran 77-based processing efficiency on each computational node. Our implementation of the ideas presented here in the first authors RIEMANN framework essentially permits any serial, uniform grid, stencil-based Fortran code to be turned into a parallel AMR code. In this paper we first describe our strategy for using Fortran 90 in an object-oriented fashion. This permits AMR applications to be expressed in terms of familiar abstractions that are natural to the process of solving AMR hierarchies. We then describe the OpenMP features that are useful for parallel processing of AMR hierarchies in a load balanced fashion on multiprocessors. The automatic, parallel regridding of AMR hierarchies is also described. We then present a very efficient load balancer and show how it is to be used for load balanced solution of AMR hierarchies. Our load balancer is extremely general and should also see use in other disciplines. We follow this up with the application of the parallel AMR techniques developed here to the solution of elliptic and hyperbolic problems. For our elliptic problem we choose parallel, self-adaptive multigrid as an example. For our hyperbolic problem we choose time-dependent MHD as an example. In either case illustrative information is given about the adaptive processing of these systems. We also provide detailed scalability studies for both the above-mentioned problems which show that our methods scale extremely well up to several hundreds of processors.

UCLA Parallel PIC Framework

Abstract The UCLA Parallel PIC Framework (UPIC) has been developed to provide trusted components for the rapid construction of new, parallel Particle-in-Cell (PIC) codes. The Framework uses object-based ideas in Fortran95, and is designed to provide support for various kinds of PIC codes on various kinds of hardware. The focus is on student programmers. The Framework supports multiple numerical methods, different physics approximations, different numerical optimizations and implementations for different hardware. It is designed with “defensive” programming in mind, meaning that it contains many error checks and debugging helps. Above all, it is designed to hide the complexity of parallel processing. It is currently being used in a number of new Parallel PIC codes.

Status and directions for the PYRAMID parallel unstructured AMR library

This is a status report on our progress with the development of PYRAMID, a Fortran 90/95-based library for parallel unstructured adaptive mesh refinement. The library has been designed to simplify the use of adaptive methods in computational science applications by introducing many advanced software engineering features. In this paper, design and performance issues are described concluding with a discussion of our future development plans.

The transition and adoption to modern programming concepts for scientific computing in Fortran

This paper describes our experiences in the early exploration of modern concepts introduced in Fortran90 for large-scale scientific programming. We review our early work in expressing object-oriented concepts based on the new Fortran90 constructs - foreign to most programmers at the time - our experimental work in applying them to various applications, the impact on the WG5/J3 standards committees to consider formalizing object-oriented constructs for later versions of Fortran, and work in exploring how other modern programming techniques such as Design Patterns can and have impacted our software development. Applications will be drawn from plasma particle simulation and finite element adaptive mesh refinement for solid earth crustal deformation modeling.

An evaluation of the Xilinx Virtex-4 FPGA for on-board processing in an advanced imaging system

The multi-angle spectro-polarimetric imager (MSPI) is an advanced camera system currently under development at JPL for possible future consideration on a satellite based Aerosol-Cloud-Environment (ACE) interaction study as outlined in the National Academies 2007 decadal survey. In an attempt to achieve necessary accuracy of the degree of linear polarization of better than 0.5%, the light in the optical system is subjected to a complex modulation designed to make the overall system robust against many instrumental artifacts that have plagued such measurements in the past. This scheme involves two photoelastic modulators that are beating in a carefully selected pattern against each other [1]. In order to properly sample this modulation pattern, each of the proposed nine cameras in the system needs to read out its imager array about 1000 times per second, resulting in two orders of magnitude more data than can typically be downlinked from the satellite. The onboard processing required to compress this data involves least-squares fits of Bessel functions to data from every pixel, effectively in real-time, thus requiring an on-board computing system with advanced data processing capabilities in excess of those commonly available for space flight

On parallel object oriented programming in Fortran 90

The C++ programming language [6, 10] is well-known for its support of object oriented concepts, useful in abstraction modeling. Containing many important features, its popularity is growing with a new generation of scientists anxious to bring clarity and flexibility to their programming efforts. Nevertheless, most of the scientific applications in development and use today are based on Fortran, the most popular language for scientific programming.Fortran is not a static language, it has continually evolved to include the most recent proven ideas and concepts garnered from other programming languages. Until recently, many of the most modern features were not available, complicating abstraction modeling for large scale development projects. This can make software difficult to comprehend, unsafe and potentially useless. The emergence of Fortran 90 [3] has dramatically changed the prospects of Fortran programming. Not only are many of the most modern aspects of programming language techniques included in the standard, there are also specific new additions that will undoubtedly affect the next generation of all languages used in scientific programming [8].