Scientific Codes Research Articles

Reducing energy usage in resource-intensive Java-based scientific applications via micro-benchmark based code refactorings

In-silico research has grown considerably. Today?s scientific code involves long-running computer simulations and hence powerful computing infrastructures are needed. Traditionally, research in high-performance computing has focused on executing code as fast as possible, while energy has been recently recognized as another goal to consider. Yet, energy-driven research has mostly focused on the hardware and middleware layers, but few efforts target the application level, where many energy-aware optimizations are possible. We revisit a catalog of Java primitives commonly used in OO scientific programming, or micro-benchmarks, to identify energy-friendly versions of the same primitive. We then apply the micro-benchmarks to classical scientific application kernels and machine learning algorithms for both single-thread and multi-thread implementations on a server. Energy usage reductions at the micro-benchmark level are substantial, while for applications obtained reductions range from 3.90% to 99.18%.

Facilitating Collaborative Analysis in SWAN

SWAN (Service for Web-based ANalysis) is a CERN service that allows users to perform interactive data analysis in the cloud, in a “software as a service” model. It is built upon the widely-used Jupyter notebooks, allowing users to write - and run - their data analysis using only a web browser. By connecting to SWAN, users have immediate access to storage, software and computing resources that CERN provides and that they need to do their analyses. Besides providing an easier way of producing scientific code and results, SWAN is also a great tool to create shareable content. From results that need to be reproducible, to tutorials and demonstrations for outreach and teaching, Jupyter notebooks are the ideal way of distributing this content. In one single file, users can include their code, the results of the calculations and all the relevant textual information. By sharing them, it allows others to visualize, modify, personalize or even re-run all the code. In that sense, this paper describes the efforts made to facilitate sharing in SWAN. Given the importance of collaboration in our scientific community, we have brought the sharing functionality from CERNBox, CERN’s cloud storage service, directly inside SWAN. SWAN users have available a new and redesigned interface where theycan share “Projects”: a special kind of folder containing notebooks and other files, e.g., like input datasets and images. When a user shares a Project with some other users, the latter can immediately see andwork with the contents of that project from SWAN.

동중서의 과학 음양 동태적 상대론

This Dong Zhongshu (董仲舒BC179-104) is a philosopher who thought that the concept of yin and yang descending from whales was a very real existence code and a scientific code. He built a foundation stone with a scientific and yin-yang concept that was firmly established in establishing his huge ideological system, and established a universal human value on it. Therefore, his philosophical system has been sustained for over a thousand years without being firmly destroyed and contributed to the settlement of the culture of the Orient as a culture of Yin and Yang. This yin and yang concept is derived from the origin of the universe, and is also the law of operation in the solar system. This concept is initially written as a sign character, and then converted into a character code, and its essence is embellished. Therefore, the logic of the code character has weakened and the emotionality of the character code has evolved. Dong zhongshu(董仲舒) who grasped the essence of this, used his philosophy back to the original purpose of the Yin and Yang concept in order to establish a logically solid philosophical system. Yin and Yang are originally an unchanging concept, so they are best judged to establish an irreversible truth system. From this, the truth system based on sociological statistics descending from Confucius was transformed into a scientific irreversible truth system in the East. The transition to the scientific truth system of the East and West has been a great success and has been enjoyed and denied in China for over 2,000 years. In fact, this is based on the fact that mankind on Earth is in the system of this sun and can not help but be applied to the law of yin and yang. This paper uses the term science and yin and yang because Yin and Yang, the first foundation stone concept of oriental philosophy, is a scientific code.

The VOLNA-OP2 tsunami code (version 1.5)

Abstract. In this paper, we present the VOLNA-OP2 tsunami model and implementation; a finite-volume non-linear shallow-water equation (NSWE) solver built on the OP2 domain-specific language (DSL) for unstructured mesh computations. VOLNA-OP2 is unique among tsunami solvers in its support for several high-performance computing platforms: central processing units (CPUs), the Intel Xeon Phi, and graphics processing units (GPUs). This is achieved in a way that the scientific code is kept separate from various parallel implementations, enabling easy maintainability. It has already been used in production for several years; here we discuss how it can be integrated into various workflows, such as a statistical emulator. The scalability of the code is demonstrated on three supercomputers, built with classical Xeon CPUs, the Intel Xeon Phi, and NVIDIA P100 GPUs. VOLNA-OP2 shows an ability to deliver productivity as well as performance and portability to its users across a number of platforms.

Philosophically Speaking...

I like nothing so much as a good philosophical discussion. For one thing, it just feels so delightfully scientific to be bandying about high minded terms like "epistemology," "ontology," "realism," "relativism," and "paradigm" with great abandon. For another thing, it is simply essential in my view of the world of science to which I enjoy belonging that one should be fully engaged in the ethical and normative underpinnings of scientific practice. That, to me, operationally characterizes philosophy of science. Our scientific philosophies facilitate the debating, codifying, and explicating of our "agreed-to rules of the road" for doing our work. They are our scientific code of conduct, so to speak. In my way of thinking, the rules of the road are important for all good researchers to understand and share if we are to hew faithfully to our paradigms and do good normal science research. The problem for me is that I see the emerging debate over whether our field is a science or not through two distinct lenses, and I'm getting some parallax out of it. I've earned two doctorates at two different stages of my career; one in marketing when I was much younger, and one more recently in information systems. That does not make me any smarter than the average bear, and it could certainly be argued that it's a sure sign of not being smarter, since one could say I had to do it twice to get it right. Yet, it has afforded me a very unique perspective on the emerging ontological debate about our discipline because, quite literally, I Have Been There Before! I've studied the Philosophy of Science two fulsome times in my career, and I've gotten some interesting perspectives each time as each was in the midst of an existential debate over status, and both of these experience bear upon my agenda-setting here, as an editor. While learning my scientific craft as a first-time doctoral student in marketing, I reveled in the debate that much of academic marketing was enmeshed in during the 80s on whether marketing was a science or a technology and if a science, how best to be practiced. We future scientists all read Kuhn (1970) in our philosophy of science seminar, as well as Dubin (1978) and a flock of excellent philosophical essays collected in a tome edited by the redoubtable Jagdish Sheth (Sheth & Garrett, 1986) - a philosophy of science volume that many in marketing and elsewhere still use, aged though it might be. We marketers also saw a collection of philosophical essays by thought leaders of the field under such titles as "Marketing, Scientific Progress, and the Scientific Method" (Anderson, 1983), "On Making Marketing Science more Scientific" (Arndt, 1985), "Paradigms Lost" (Deshpande, 1983), and "Metatheory and Metamethodology in Marketing" (Leong, 1985). The debate in marketing continued well past that point and has extended into recent years (e.g., Brown, 1996; Easton, 2002), indicating that the debate we have now in information systems has years yet to go. It is not a simple question we deal with, and the answers take time and fulsome consideration.

Application of Metaprogramming and Generic Programming in Multiscale Modeling

Numerical modeling is a tool commonly used by both researchers and engineers. For several reasons, the quality of scientific codes frequently deprecates. One of the possible remedies is the application of advanced programming and software development methods. In this paper, we introduce the application of metaprogramming and generic programming in C++ to control the correctness of multiscale models. Additionally, it is shown how both methods increase reusability and quality of the code. A short introduction to metaprogramming and generic programming is included, as well as the proof of the concept. Exemplary codes are also included and discussed.

Parallel and vectorized implementation of analytic evaluation of boundary integral operators

In this paper, we describe an efficient analytic evaluation of boundary integral operators. Firstly, we concentrate on a novel approach based on the simultaneous evaluation of all three linear shape functions defined on a boundary triangle. This results in a speedup of 2.35–3.15 times compared to the old approach of separate evaluations. In the second part we comment on the OpenMP parallelized and vectorized implementation of the suggested formulae. The employed code optimizations include techniques such as data alignment and padding, array-of-structures to structure-of-arrays data transformation, or unit-strided memory accesses. The presented scalability results, with respect both to the number of threads employed and the width of the SIMD register obtained on an Intel® Xeon™ processor and two generations of the Intel® Xeon Phi™ family (co)processors, validate the performed optimizations and show that vectorization needs to be an inherent part of modern scientific codes.

Numerical integration of stochastic differential equations: A parallel cosmic ray modulation implementation on Africa’s fastest computer

Three-dimensional studies of the transport and modulation of cosmic ray particles in turbulent astrospheres require large-scale simulations using specialized scientific codes. Essentially, a multi-dimensional Fokker-Planck type equation (a parabolic diffusion equation) must be integrated numerically. One such approach is to convert the relevant transport equation into a set of stochastic differential equations (SDEs), with the latter much easier to handle numerically. Due to the growing demand for high performance computing resources, research into the application of effective and suitable numerical algorithms to solve such equations is needed. We present a case study of the performance of a custom-written FORTRAN SDE numerical solver on the CHPC (Centre for High Performance Computing) Lengau cluster in South Africa for a realistic test problem with different set-ups. It is shown that SDE codes can scale very well on large parallel computing platforms. Finally, we consider an extremely computationally expensive application of the SDE approach to cosmic ray modulation, studying the behaviour of galactic cosmic ray proton latitude gradients and relative amplitudes in a physics-first manner. This is done using a modulation code that employs diffusion coefficients derived from first principles, which in turn are functions of turbulence quantities in reasonable agreement with spacecraft observations and modelled using a two-component turbulence transport model (TTM). We show that this approach leads to reduced latitude gradients qualitatively in line with spacecraft observations of the same, without making ad hoc assumptions as to anisotropic perpendicular diffusion coefficients as are often made in many cosmic ray modulation studies.

Fidimag – A Finite Difference Atomistic and Micromagnetic Simulation Package

Fidimag is an open-source scientific code for the study of magnetic materials at the nano- or micro-scale using either atomistic or finite difference micromagnetic simulations, which are based on solving the Landau-Lifshitz-Gilbert equation. In addition, it implements simple procedures for calculating energy barriers in the magnetisation through variants of the nudged elastic band method. This computer software has been developed with the aim of creating a simple code structure that can be readily installed, tested, and extended. An agile development approach was adopted, with a strong emphasis on automated builds and tests, and reproducibility of results. The main code and interface to specify simulations are written in Python, which allows simple and readable simulation and analysis configuration scripts. Computationally costly calculations are written in C and exposed to the Python interface as Cython extensions. Docker containers are shipped for a convenient setup experience. The code is freely available on GitHub and includes documentation and examples in the form of Jupyter notebooks.

Dfanalyzer

We present DfAnalyzer, a tool that enables monitoring, debugging, steering, and analysis of dataflows while being generated by scientific applications. It works by capturing strategic domain data, registering provenance and execution data to enable queries at runtime. DfAnalyzer provides lightweight dataflow monitoring components to be invoked by high performance applications. It can be plugged in scientific code scripts, or Spark applications, in the same way users already plug visualization library components. During this demo, we will show how DfAnalyzer captures the dataflow, provenance, as well as how it provides runtime data analyses of applications. We will also encourage attendees to use DfAnalyzer for their own applications.

A Minimally Intrusive Low-Memory Approach to Resilience for Existing Transient Solvers

We propose a novel, minimally intrusive approach to adding fault tolerance to existing complex scientific simulation codes, used for addressing a broad range of time-dependent problems on the next generation of supercomputers. Exascale systems have the potential to allow much larger, more accurate and scale-resolving simulations of transient processes than can be performed on current petascale systems. However, with a much larger number of components, exascale computers are expected to suffer a node failure every few minutes. Many existing parallel simulation codes are not tolerant of these failures and existing resilience methodologies would necessitate major modifications or redesign of the application. Our approach combines the proposed user-level failure mitigation extensions to the Message-Passing Interface (MPI), with the concepts of message-logging and remote in-memory checkpointing, to demonstrate how to add scalable resilience to transient solvers. Logging MPI communication reduces the storage requirement of static data, such as finite element operators, and allows a spare MPI process to rebuild these data structures independently of other ranks. Remote in-memory checkpointing avoids disk I/O contention on large parallel filesystems. A prototype implementation is applied to Nektar++, a scalable, production-ready transient simulation framework. Forward-path and recovery-path performance of the resilience algorithm is analysed through experiments using the solver for the incompressible Navier–Stokes equations, and strong scaling of the approach is observed.

Domain-specific acceleration and auto-parallelization of legacy scientific code in FORTRAN 77 using source-to-source compilation

Massively parallel accelerators such as GPGPUs, manycores and FPGAs represent a powerful and affordable tool for scientists who look to speed up simulations of complex systems. However, porting code to such devices requires a detailed understanding of heterogeneous programming tools and effective strategies for parallelization. In this paper we present a source to source compilation approach with whole-program analysis to automatically transform single-threaded FORTRAN 77 legacy code into OpenCL-accelerated programs with parallelized kernels.The main contributions of our work are: (1) whole-source refactoring to allow any subroutine in the code to be offloaded to an accelerator. (2) Minimization of the data transfer between the host and the accelerator by eliminating redundant transfers. (3) Pragmatic auto-parallelization of the code to be offloaded to the accelerator by identification of parallelizable maps and reductions.We have validated the code transformation performance of the compiler on the NIST FORTRAN 78 test suite and several real-world codes: the Large Eddy Simulator for Urban Flows, a high-resolution turbulent flow model; the shallow water component of the ocean model Gmodel; the Linear Baroclinic Model, an atmospheric climate model and Flexpart-WRF, a particle dispersion simulator.The automatic parallelization component has been tested on as 2-D Shallow Water model (2DSW) and on the Large Eddy Simulator for Urban Flows (UFLES) and produces a complete OpenCL-enabled code base. The fully OpenCL-accelerated versions of the 2DSW and the UFLES are resp. 9x and 20x faster on GPU than the original code on CPU, in both cases this is the same performance as manually ported code.

Enabling rootless Linux Containers in multi-user environments: The udocker tool

Containers are increasingly used as means to distribute and run Linux services and applications. In this paper we describe the architectural design and implementation of udocker, a tool which enables the user to execute Linux containers in user mode. We also present a few practical applications, using a range of scientific codes characterized by different requirements: from single core execution to MPI parallel execution and execution on GPGPUs.

Resilient parallel computing on volunteer PC grids

SummaryVolunteer PC hosts represent massive computation capacity at a low cost but are challenging to employ for general parallel computing. This paper presents the design, execution model, implementation, and evaluation of the Volpex framework for robust execution of parallel codes on volunteer PC grids characterized by system and network heterogeneity, varying availability, and frequent failures. The communication model is based on one‐sided Put/Get calls to an abstract global shared space enhanced to support multiple autonomous instances of the same process at different stages of execution. Our approach customizes and combines the use of replication, checkpointing, and host selection. This presents formidable challenges that are addressed in this work; efficient checkpointing of distributed replicated processes, dynamic management of redundancy, quick restart in a distributed environment, and application specific host selection. The integrated runtime system is shown to effectively execute moderate size, coarse‐grain, communicating codes on a worldwide distributed volunteer environment, a new milestone in volunteer computing. Extensive evaluation is conducted with example scientific codes on a pool of around 600 volunteer hosts. The results demonstrate the trade‐offs in deploying checkpointing, redundancy, and host selection, and how these methods combine to provide application performance that is close to the ideal failure free performance.

Re-run, Repeat, Reproduce, Reuse, Replicate: Transforming Code into Scientific Contributions.

Scientific code is different from production software. Scientific code, by producing results that are then analyzed and interpreted, participates in the elaboration of scientific conclusions. This imposes specific constraints on the code that are often overlooked in practice. We articulate, with a small example, five characteristics that a scientific code in computational science should possess: re-runnable, repeatable, reproducible, reusable, and replicable. The code should be executable (re-runnable) and produce the same result more than once (repeatable); it should allow an investigator to reobtain the published results (reproducible) while being easy to use, understand and modify (reusable), and it should act as an available reference for any ambiguity in the algorithmic descriptions of the article (replicable).

Professional Attitude in Iranian Nursing Students

Introduction: The first and most critical stage in nursing profession is when an individual enters the educational or apprenticeship environment as a nursing student. Therefore, the students' professional attitudes and behaviours are very important during the courses. Aim: To determine the professional attitude in Iranian Nursing Students. Materials and Methods: This descriptive cross-sectional study was conducted from October 2015 to October 2016 at Ilam University of Medical Sciences. One hundred fourteen nursing students who studied in fourth to eighth semesters were randomly selected through proportionate stratified random sampling. Data collection tools consisted of a demographic information form and the Inventory to Measure Professional Attitudes in Student Nurses. Data analysis was performed using descriptive and inferential statistics through SPSS 18, while p<0.05 was considered significant. Results: A total of 75 (65.8) of the student were interested in the nursing profession. A 60.52 and 15.8 of students considered educators and nurses to be effective in their professionalism, respectively. A 13.2 of the subjects were members of the Iranian Nursing Organization. The mean and standard deviation for the total score of the professional attitude was 91.01 +/- 15.7, which was above average. Scores in different factors of professionalism were contribution to the increase in scientific information load (15.97 +/- 3.35), collaboration (15.97 +/- 3.35), community service (10.93 +/- 2.74), ethical codes and theory (10.73 +/- 2.55), competence and continuous education (9.76 +/- 2.51), participation in professional organisations and professional development (9.61 +/- 2.17), autonomy (9.51 +/- 2.00) and working in committees (6.85 +/- 1.82). Conclusion: Iranian nursing students are at moderate level of professionalism. Therefore, it seems necessary to identify the existing weaknesses in different aspects and try to fix them, while improving their strengths during student life.

Visualizing the Topology and Data Traffic of Multi-Dimensional Torus Interconnect Networks

Torus networks are an attractive topology in supercomputing, balancing the tradeoff between network diameter and hardware costs. The nodes in a torus network are connected in a $k$ -dimensional wrap-around mesh where each node has $2k$ neighbors. Effectively utilizing these networks can significantly decrease parallel communication overhead and in turn the time necessary to run large parallel scientific and data analysis applications. The potential gains are considerable —5-D torus networks are used in the majority of the top 10 machines in the November 2017 Graph 500 list. However, the multi-dimensionality of these networks makes it difficult for analysts to diagnose ill-formed communication patterns and poor network utilization since human spatial understanding is by and large limited to 3-Ds. We propose a method based on a space-filling Hilbert curve to linearize and embed the network into a ring structure, visualizing the data traffic as flowlines in the ring interior. We compare our method with traditional 2-D embedding techniques designed for high-dimensional data, such as MDS and RadViz, and show that they are inferior to ours in this application. As a demonstration of our approach, we visualize the data flow of a massively parallel scientific code on a 5-D torus network.

Evaluating attainable memory bandwidth of parallel programming models via BabelStream

Many scientific codes consist of memory bandwidth bound kernels. One major advantage of many-core devices such as general purpose graphics processing units (GPGPUs) and the Intel Xeon Phi is their focus on providing increased memory bandwidth over traditional CPU architectures. Peak memory bandwidth is usually unachievable in practice and so benchmarks are required to measure a practical upper bound on expected performance. We augment the standard STREAM kernels with a dot product kernel to investigate the performance of simple reduction operations on large arrays. The choice of programming model should ideally not limit the achievable performance on a device. BabelStream (formally GPU-STREAM) has been updated to incorporate a wide variety of the latest parallel programming models, all implementing the same parallel scheme. As such this tool can be used as a kind of Rosetta Stone which provides both a cross-platform and cross-programming model array of results of achievable memory bandwidth.

The dividends of investing in computational software design: A case study

A significant fraction of computational software for scientific research grows through accretion. In a common scenario, a small group develops a code for a specific purpose. Others find the software useful, so they add to it for their own use. The software grows to the point where its management becomes intractable and scientific results obtained from it become unreliable. This is in stark contrast with a small number of scientific codes that have undergone a design process, be it due to an upfront investment, or when haphazardly grown codes have reset and started again. At a minimum, these codes reduce the time to obtain research results for the communities they serve because individual researchers do not have to develop their own codes. They provide further benefits; the results they produce are more reproducible due to greater scrutiny, leading to better science. One of the more overlooked benefits, which is perhaps of greater significance, is that a well-designed code can expand to serve communities beyond the ones it was designed for. Thus, research communities with similar computational requirements can symbiotically improve computation-based research for each other. In this article, we present a case study of FLASH, a code that was designed and developed for simulating thermonuclear runaways such as novae and type Ia supernovae in astrophysics. Designed to be modular and extensible, users from several diverse research areas have added capabilities to it and adapted it for their own communities. Examples include cosmology, high-energy density physics, core-collapse supernovae, star formation, fluid–structure interactions, and chemical combustion. We give a summary of design features that facilitated the expansion and quantify the effort needed to expand into some of the above-mentioned fields. We also quantify the impact on different communities by mining the database of publications using FLASH, collected by its developers.

Verifying spatial properties of array computations

Arrays computations are at the core of numerical modelling and computational science applications. However, low-level manipulation of array indices is a source of program error. Many practitioners are aware of the need to ensure program correctness, yet very few of the techniques from the programming research community are applied by scientists. We aim to change that by providing targetted lightweight verification techniques for scientific code. We focus on the all too common mistake of array offset errors as a generalisation of off-by-one errors. Firstly, we report on a code analysis study on eleven real-world computational science code base, identifying common idioms of array usage and their spatial properties. This provides much needed data on array programming idioms common in scientific code. From this data, we designed a lightweight declarative specification language capturing the majority of array access patterns via a small set of combinators. We detail a semantic model, and the design and implementation of a verification tool for our specification language, which both checks and infers specifications. We evaluate our tool on our corpus of scientific code. Using the inference mode, we found roughly 87,000 targets for specification across roughly 1.1 million lines of code, showing that the vast majority of array computations read from arrays in a pattern with a simple, regular, static shape. We also studied the commit logs of one of our corpus packages, finding past bug fixes for which our specification system distinguishes the change and thus could have been applied to detect such bugs.