Derived Data Types Research Articles

A Parallel 3-D HIE-FDTD Method using the MPI Library

This paper presents the implementation of the parallel hybrid implicit-explicit finite-difference time-domain (HIE-FDTD) method using the Message Passing Interface (MPI) library. The method proves to be very effective in simulating large-scale three-dimensional electromagnetic problems with fine structures in one direction. For the decomposition of the computational volume in the HIE-FDTD method, an MPI Cartesian 2D topology is implemented, allowing arbitrary division of the volume in two directions. Derived data types provided in the MPI library are employed to optimize inter-process communication. High accuracy and efficiency are subsequently demonstrated through a numerical example of a frequency-selected surface (FSS). It shows that the proposed method is very suitable for parallel computing, and the parallel efficiency maintains above 80% for different numbers of processes.

Network-Assisted Noncontiguous Transfers for GPU-Aware MPI Libraries

The importance of graphics processing units (GPUs) in accelerating HPC applications is evident by the fact that a large number of supercomputing clusters are GPU enabled. Many of these HPC applications use message passing interface (MPI) as their programming model. These MPI applications frequently exchange data that is noncontiguous in GPU memory. MPI provides derived datatypes (DDTs) to represent such data. Past research on DDTs mainly focused on optimizing the pack–unpack kernels. Modern HCAs are capable of gathering/scattering data from/to noncontiguous GPU memory regions. We propose a low-overhead HCA-assisted scheme to improve the performance of GPU-based noncontiguous exchanges without the GPU-based pack–unpack kernels. We show that the proposed scheme provides up to 2× benefits compared to the existing pack-based scheme at the benchmark level. Furthermore, we show up to 17% improvement with the SW4Lite application compared to other MPI libraries, such as MVAPICH2-GDR and OpenMPI+UCX.

Blib is a multi-module simulation platform for genetics studies and intelligent breeding

Simulation is an efficient approach for the investigation of theoretical and applied issues in population and quantitative genetics, and animal and plant breeding. In this study, we report a multi-module simulation platform called Blib, that is able to handle more complicated genetic effects and models than existing tools. Two derived data types are first defined in Blib, one to hold the required information on genetic models, and the other one to represent the genetics and breeding populations. A number of subroutines are then developed to perform specific tasks. Four case studies are present as examples to show the applications of Blib, i.e., genetic drift of multiple alleles in randomly mating populations, joint effects of neutral mutation and genetic drift, comparison of mass versus family selection, and choice of testers in hybrid breeding. Blib together with its application modules, has great potential to benefit theoretical genetic studies and intelligent breeding by simulating and predicting outcomes in a large number of scenarios, and identifying the best optimum selection and crossing schemes.

Fortran interface layer of the framework for developing particle simulator FDPS

Abstract Numerical simulations based on particle methods have been widely used in various fields including astrophysics. To date, various versions of simulation software have been developed by individual researchers or research groups in each field, through a huge amount of time and effort, even though the numerical algorithms used are very similar. To improve the situation, we have developed a framework, called FDPS (Framework for Developing Particle Simulators), which enables researchers to develop massively parallel particle simulation codes for arbitrary particle methods easily. Until version 3.0, FDPS provided an API (application programming interface) for the C++ programming language only. This limitation comes from the fact that FDPS is developed using the template feature in C++, which is essential to support arbitrary data types of particle. However, there are many researchers who use Fortran to develop their codes. Thus, the previous versions of FDPS require such people to invest much time to learn C++. This is inefficient. To cope with this problem, we developed a Fortran interface layer in FDPS, which provides API for Fortran. In order to support arbitrary data types of particle in Fortran, we design the Fortran interface layer as follows. Based on a given derived data type in Fortran representing particle, a Python script provided by us automatically generates a library that manipulates the C++ core part of FDPS. This library is seen as a Fortran module providing an API of FDPS from the Fortran side and uses C programs internally to interoperate Fortran with C++. In this way, we have overcome several technical issues when emulating a ‘template’ in Fortran. Using the Fortran interface, users can develop all parts of their codes in Fortran. We show that the overhead of the Fortran interface part is sufficiently small and a code written in Fortran shows a performance practically identical to the one written in C++.

Fortran 2008 coarrays

Coarrays are a Fortran 2008 standard feature intended for SIMD type parallel programming. The runtime environment starts a number of identical executable images of the coarray program, on multiple processors, which could be actual physical processors or threads. Each image has a unique number and its private address space. Ordinary variables are private to an image. Coarray variables are available for read/write access from any other image. Coarray communications are of "single sided" type, i.e. a remote call from imageA to image B does not need to be accompanied by a corresponding call in image B. This feature makes coarray programming a lot simpler than MPI. The standard provides synchronisation intrinsics to help avoid race conditions or deadlocks. Any ordinary variable can be made into a coarray - scalars, arrays, intrinsic or derived data types, pointers, allocatables are all allowed. Coarrays can be declared in, and passed to, procedures. Coarrays are thus very flexible and can be used for a number of purposes. For example a collection of coarrays from all or some images can be thought of as a large single array. This is precisely the inverse of the model partitioning logic, typical in MPI programs. A coarray program can exploit functional parallelism too, by delegating dis- tinct tasks to separate images or teams of images. Coarray collectives are expected to become a part of the next version of the Fortran standard. A major unresolved problem of coarray programming is the lack of standard parallel I/O facility in Fortran. In this paper several simple complete coarray programs are shown and compared to alternative parallel technologies - OpenMP, MPI and Fortran 2008 intrinsic "do concurrent". Inter image communication patterns and data transfer are illustrated. An example of a materials microstructure simulation coarray program scaled up to 32k cores is shown. Problems with coarray I/O at this scale are highlighted and addressed with the use of MPI-I/O. A hybrid MPI/coarray programming is discussed and illustrated with a finite element/cellular automata (CAFÉ) multi-scale model. The paper completes with a description of the new coarray language features, expected in the 2015 Fortran standard, and with a brief list of coarray resources

A Neuroinformatics Framework For Linking Genetic and Neuroimaging Data

Event Abstract Back to Event A Neuroinformatics Framework For Linking Genetic and Neuroimaging Data Timothy O'Keefe1*, Victor Petrov1, Randy Buckner1 and Gabriele Fariello1 1 Harvard University, Center for Brain Science, United States A Neuroinformatics Framework For Linking Genetic and Neuroimaging Data Timothy M. O’Keefe1, Victor I. Petrov2, Randy L. Buckner1,2,3 and Gabriele R. Fariello1,2 1. Harvard University, Center for Brain Science 2. Athinoula A. Martinos Center for Biomedical Imaging, Massachusetts General Hospital 3. Howard Hughes Medical Institute An informatics challenge has emerged at the intersection of genetics and human brain imaging research. The cause of this challenge is situated in that each modality is data intensive and requires significant processing to derive useful information. Discovering links between modalities necessitates a system for capturing and vetting data, deriving measures, and linking derived data types. In large-scale projects, there exists a further need to collect and share data between institutions and computational environments. To address these challenges, we have developed a neuroinformatics framework. The framework offers a system that is capable of automatically processing acquired data and provides access to the raw, quality control, computationally derived, and summary data. The framework is built upon a custom installation of the eXtensible Neuroimaging Archive Toolkit (XNAT; Marcus et al. 2007), advancements in MRI data acquisition methods, automated processing pipelines, online cognitive, personality and behavioral assessments, and programmatic APIs for data retrieval and subsequent processing. To illustrate the utility of this approach, the framework has been utilized over the past two years to power the Brain Genomics Superstruct Project as an installation known as “GSPCentral”. GSPCentral has since succeeded in capturing neuroimaging (e.g., fMRI, anatomical), genetics, cognitive (e.g., WAIS III, WMS III), behavioral (e.g., STAI-T, POMS), and derived imaging data (e.g., Morphometry, Functional Connectivity) for approximately 3000 human participants acquired across 20 investigators and 5 matched MRI scanners. This large sample has already enabled researchers to explore aspects of neuroanatomy, behavior, and cognition including revealing the relations between brain structure and personality traits (e.g., anxiety), exposing the organization of large-scale networks, and quantifying the hemispheric asymmetry of functional networks. The challenges of the approach will be discussed as well as how these derived brain and behavioral measures are being linked to genetic information. Keywords: computational neuroscience, General neuroinformatics Conference: 4th INCF Congress of Neuroinformatics, Boston, United States, 4 Sep - 6 Sep, 2011. Presentation Type: Poster Presentation Topic: General neuroinformatics Citation: O'Keefe T, Petrov V, Buckner R and Fariello G (2011). A Neuroinformatics Framework For Linking Genetic and Neuroimaging Data. Front. Neuroinform. Conference Abstract: 4th INCF Congress of Neuroinformatics. doi: 10.3389/conf.fninf.2011.08.00008 Copyright: The abstracts in this collection have not been subject to any Frontiers peer review or checks, and are not endorsed by Frontiers. They are made available through the Frontiers publishing platform as a service to conference organizers and presenters. The copyright in the individual abstracts is owned by the author of each abstract or his/her employer unless otherwise stated. Each abstract, as well as the collection of abstracts, are published under a Creative Commons CC-BY 4.0 (attribution) licence (https://creativecommons.org/licenses/by/4.0/) and may thus be reproduced, translated, adapted and be the subject of derivative works provided the authors and Frontiers are attributed. For Frontiers’ terms and conditions please see https://www.frontiersin.org/legal/terms-and-conditions. Received: 17 Oct 2011; Published Online: 19 Oct 2011. * Correspondence: Dr. Timothy O'Keefe, Harvard University, Center for Brain Science, Cambridge, United States, timothy_okeefe@harvard.edu Login Required This action requires you to be registered with Frontiers and logged in. To register or login click here. Abstract Info Abstract The Authors in Frontiers Timothy O'Keefe Victor Petrov Randy Buckner Gabriele Fariello Google Timothy O'Keefe Victor Petrov Randy Buckner Gabriele Fariello Google Scholar Timothy O'Keefe Victor Petrov Randy Buckner Gabriele Fariello PubMed Timothy O'Keefe Victor Petrov Randy Buckner Gabriele Fariello Related Article in Frontiers Google Scholar PubMed Abstract Close Back to top Javascript is disabled. Please enable Javascript in your browser settings in order to see all the content on this page.

Automatic reconstruction of data types in the decompilation problem

An algorithm for the automatic reconstruction of data types from the assembler code produced by a C compiler is described. The types of the variables that are placed on the stack and in the static memory are reconstructed using an iterative algorithm that uses a lattice over the properties of the data types. The derived data types are reconstructed by constructing the set of possible offsets of the elements of these types (fields in the case of structures and array elements in the case of arrays). This algorithm is used in the tool for decompiling assembler codes into C that is currently developed by the authors.

ADF95: Tool for automatic differentiation of a FORTRAN code designed for large numbers of independent variables

ADF95 is a tool to automatically calculate numerical first derivatives for any mathematical expression as a function of user defined independent variables. Accuracy of derivatives is achieved within machine precision. ADF95 may be applied to any FORTRAN 77/90/95 conforming code and requires minimal changes by the user. It provides a new derived data type that holds the value and derivatives and applies forward differencing by overloading all FORTRAN operators and intrinsic functions. An efficient indexing technique leads to a reduced memory usage and a substantially increased performance gain over other available tools with operator overloading. This gain is especially pronounced for sparse systems with large number of independent variables. A wide class of numerical simulations, e.g., those employing implicit solvers, can profit from ADF95. Program summary Title of program: ADF95 Catalogue identifier: ADVI Program summary URL: http://cpc.cs.qub.ac.uk/summaries/ADVI Program obtainable from: CPC Program Library, Queen's University of Belfast, N. Ireland Computer for which the program is designed: all platforms with a FORTRAN 95 compiler Programming language used: FORTRAN 95 No. of lines in distributed program, including test data, etc.: 3103 No. of bytes in distributed program, including test data, etc.: 9862 Distribution format: tar.gz Nature of problem: In many areas in the computational sciences first order partial derivatives for large and complex sets of equations are needed with machine precision accuracy. For example, any implicit or semi-implicit solver requires the computation of the Jacobian matrix, which contains the first derivatives with respect to the independent variables. ADF95 is a software module to facilitate the automatic computation of the first partial derivatives of any arbitrarily complex mathematical FORTRAN expression. The program exploits the sparsity inherited by many set of equations thereby enabling faster computations compared to alternate differentiation tools Solution method: A class is constructed which applies the chain rule of differentiation to any FORTRAN expression, to compute the first derivatives by forward differencing. An efficient indexing technique leads to a reduced memory usage and a substantially increased performance gain when sparsity can be exploited. From a users point of view, only minimal changes to his/her original code are needed in order to compute the first derivatives of any expression in the code Restrictions: Processor and memory hardware may restrict both the possible number of independent variables and the computation time Unusual features: ADF95 can operate on user code that makes use of the array features introduced in FORTRAN 90. A convenient extraction subroutine for the Jacobian matrix is also provided Running time: In many realistic cases, the evaluation of the first order derivatives of a mathematical expression is only six times slower compared to the evaluation of analytically derived and hard-coded expressions. The actual factor depends on the underlying set of equations for which derivatives are to be calculated, the number of independent variables, the sparsity and on the FORTRAN 95 compiler

An Adaptive Finite Volume Method for Incompressible Heat Flow Problems in Solidification

An adaptive finite volume method is presented for solving incompressible heat flow problems with an unknown melt/solid interface, mainly in solidification applications, using primitive variables on a fixed collocated grid. A phase-field variable is introduced to treat the melt/solid interface, which is assumed to be diffusive, so that the complicated interfaces and phase change (using the enthalpy model) can be treated easily. The method is implemented through an object-oriented way based on adaptive mesh refinement and coarsening using dynamic data structures and derived data types of FORTRAN90. In addition to the refinement on the interfaces or boundaries, the mesh can be adapted to a solution based on numerical errors or gradients. Extensive tests are performed for cases with a fixed or free interface, and excellent agreement with the body-fitted or front tracking schemes is obtained. Furthermore, by gradual reduction of the interface thickness, the sharp-interface limit can be reached, which ensures the correctness of using a diffusive interface. The present approach is particularly suitable for problems having a complicated interface morphology as well as phase evolution, such as the phase-field simulation of dendritic growth. Two examples, without and with convection, are further given and good agreement with previous results are found.

A parallel FDTD algorithm using the MPI library

In this paper, we describe the essential elements of a parallel algorithm for the FDTD method using the MPI (message passing interface) library. To simplify and accelerate the algorithm, an MPI Cartesian 2D topology is used. The inter-process communications are optimized by the use of derived data types. A general approach is also explained for parallelizing the auxiliary tools, such as far-field computation, thin-wire treatment, etc. For PMLs, we have used a new method that makes it unnecessary to split the field components. This considerably simplifies the computer programming, and is compatible with the parallel algorithm.

Software to support numerical analysis teaching

This paper describes a Fortran90 library designed to support the teaching of numerical analysis and its applications. As well as covering traditional material it introduces recent and important ideas in numerical computation such as interval arithmetic and automatic differentiation. The library rests on a module realpac which provides real arithmetic in a range of precisions with a choice of rounding strategies. This, in turn, supports the implementation of an interval arithmetic module intpac. Derived data types and overloaded operations help inexperienced users to interface with unfamiliar data types such as intervals. The library also includes more conventional modules such as lepac for solving linear systems and minpac for nonlinear optimization. These, however, can be enhanced by being linked to more sophisticated tools for sparse matrix handling and automatic differentiation. As well as showing the main structure and scope of the software, the paper mentions some exercises that have successfully been performed by students.

Algorithm 801: POLSYS_PLP

Globally convergent, probability-one homotopy methods have proven to be very effective for finding all the isolated solutions to polynomial systems of equations. After many years of development, homotopy path trackers based on probability-one homotopy methods are reliable and fast. Now, theoretical advances reducing the number of homotopy paths that must be tracked, and in the handling of singular solutions, have made probability-one homotopy methods even more practical. POLSYS_PLP consists of Fortran 90 modules for finding all isolated solutions of a complex coefficient polynomial system of equations. The package is intended to be used in conjunction with HOMPACK90 (Algorithm 777), and makes extensive use of Fortran 90 derived data types to support a partitioned linear product (PLP) polynomial system structure. PLP structure is a generalization of m -homogeneous structure, whereby each component of the system can have a different m -homogeneous structure. The code requires a PLP structure as input, and although finding the optimal PLP structure is a difficult combinatorial problem, generally physical or engineering intuition about a problem yields a very good structure. POLSYS_PLP employs a sophisticated power series end game for handling singular solutions, and provides support for problem definition both at a high level and via hand-crafted code. Different PLP structures and their corresponding Bezout

MM90: A scalable parallel implementation of the Penn State/NCAR Mesoscale Model (MM5)

This paper describes MM90, a parallel regional weather model based on the Penn State/NCAR MM5. Parallelization of finite differencing, horizontal interpolation, and nesting on distributed-memory (message passing) computers is handled transparently using the RSL library package. Fortran90 modules, derived data types, dynamic memory allocation, pointers, and recursion are used, making the code modular, flexible, extensible, and run-time configurable. The model can dynamically sense and correct load imbalances. The paper provides performance, scaling, and load-balancing data collected on the IBM SP2 computers at Argonne National Laboratory and NASA Ames Laboratory. Future work will address the impact of parallel modifications on existing modeling software; an approach using commercially available source translation software is described.

A Fortran 90-based multiprecision system

A new version of a Fortran multiprecision computation system, based on the Fortran 90 language, is described. With this new approach, a translator program is not required—translation of Fortran code for multiprecision is accomplished by merely utilizing advanced features of Fortran 90, such as derived data types and operator extensions. This approach results in more-reliable translation and permits programmers of multiprecision applications to utilize the full power of Fortran 90. Three multiprecision data types are supported in this system: multiprecision integer, real, and complex. All the usual Fortran conventions for mixed-mode operations are supported, and many of the Fortran intrinsics, such as SIN, EXP, and MOD, are supported with multiprecision arguments. An interesting application of this software, wherein new number-theoretic identities have been discovered by means of multiprecision computations, is included also.

Control and definition modularization: an improved software design technique for organizing programs

The author proposes a technique called control and definition modularization (CDM), which derives a systematic program layout from a given structure chart using the concepts of 'control' and 'definition' modules. A control module includes processes for handling a conceptual data object not directly implementable. A definition module defines operations associated with a concrete data object implementable using a primitive or derived data type of a programming language. Grouping the operations available for each concrete data object, and keeping them separated from execution flow, improves programs maintainability. This technique extends the structured design methodology and provides designers with a systematic way of deriving informational strength modules as well as a structured physical layout from the structure chart. A program based on the CDM technique is easier to understand and maintain. This research makes a significant contribution toward bridging the gap between structured design and object-oriented concepts. >