Large Scientific Applications Research Articles

Overlaps between industrial informatics and control, data acquisition and management in Big Science

Big Science applications require very large infrastructures and often involve different countries in order to achieve important scientific results or to find solutions to the major problems of mankind, such as finding a clean and endless source of energy. Big Science applications represent not only a scientific challenge, but also large engineering applications involving a wide range of technologies shared with other industrial applications. As a consequence there is a significant overlap in technologies and approaches between Big Science and Industry. In this paper, the overlap between Big Science and industrial applications will be presented in more detail under the control perspective, that is, by highlighting the common aspects between industrial informatics and the control, data acquisition and data management in large scientific applications.

Energy-efficient virtual-machine mapping algorithm (EViMA) for workflow tasks with deadlines in a cloud environment

Processing large scientific applications generates a huge amount of data, which makes running experiments in the cloud computing environment very expensive and energy-consuming. To find an optimal solution to the workflow scheduling problem, several approaches have been presented for scheduling workflow on cloud resources. However, more efficient approaches are needed to improve cloud service delivery. In this paper, an energy-efficient virtual machine mapping algorithm (EViMA) is proposed to improve resource management in the cloud computing environment to achieve effective scheduling that reduces cloud data center energy consumption, execution makespan, and execution cost. This ensures that the requirements of cloud users are met, and improves the quality of services offered by cloud providers. Our proposed mechanism considers the heterogeneity of scheduling from both cloud users’ and workflow applications’ perspectives. Through simulation experiments on real workflow datasets, the proposed EViMA can provide better solutions for both cloud users and cloud providers by reducing energy consumption, execution makespan, and execution cost better than the state-of-the-art.

Measurable Selections: A Bridge Between Large Cardinals and Scientific Applications?

ABSTRACT There is no prospect of discovering measurable cardinals by radio astronomy, but this does not mean that higher set theory is entirely irrelevant to applied mathematics broadly construed. By way of example, the bearing of some celebrated descriptive-set-theoretic consequences of large cardinals on measurable-selection theory, a body of results originating with a key lemma in von Neumann’s work on the mathematical foundations of quantum theory, and further developed in connection with problems of mathematical economics, will be considered from a philosophical point of view.

Investigation of Cloud Scheduling Algorithms for Resource Utilization Using CloudSim

Compute Cloud comprises a distributed set of High-Performance Computing (HPC) machines to stipulate on-demand computing services to remote users over the internet. Clouds are capable enough to provide an optimal solution to address the ever-increasing computation and storage demands of large scientific HPC applications. To attain good computing performances, mapping of Cloud jobs to the compute resources is a very crucial process. Currently we can say that several efficient Cloud scheduling heuristics are available, however, selecting an appropriate scheduler for the given environment (i.e., jobs and machines heterogeneity) and scheduling objectives (such as minimized makespan, higher throughput, increased resource utilization, load balanced mapping, etc.) is still a difficult task. In this paper, we consider ten important scheduling heuristics (i.e., opportunistic load balancing algorithm, proactive simulation-based scheduling and load balancing, proactive simulation-based scheduling and enhanced load balancing, minimum completion time, Min-Min, load balance improved Min-Min, Max-Min, resource-aware scheduling algorithm, task-aware scheduling algorithm, and Sufferage) to perform an extensive empirical study to insight the scheduling mechanisms and the attainment of the major scheduling objectives. This study assumes that the Cloud job pool consists of a collection of independent and compute-intensive tasks that are statically scheduled to minimize the total execution time of a workload. The experiments are performed using two synthetic and one benchmark GoCJ workloads on a renowned Cloud simulator CloudSim. This empirical study presents a detailed analysis and insights into the circumstances requiring a load balanced scheduling mechanism to improve overall execution performance in terms of makespan, throughput, and resource utilization. The outcomes have revealed that the Sufferage and task-aware scheduling algorithm produce minimum makespan for the Cloud jobs. However, these two scheduling heuristics are not efficient enough to exploit the full computing capabilities of Cloud virtual machines.

A Pareto-based approach for CPU provisioning of scientific workflows on clouds

As of recently, cloud providers have started offering CPU resources that can be selected from a wide range of different CPU frequencies. CPU resources at higher frequencies have a higher price than CPU resources at lower frequencies that are available at a lower price. When executing applications, such as large scientific workflow applications, multiple CPU resources are required. In this case, this new pricing scheme allows users to choose from a large number of possible CPU configurations that may include relatively fast and relatively slow CPUs. However, such an option raises the problem of how to select appropriate CPU frequency configurations that strike a good balance between cost and execution time performance. As the search space is large with a wide range of choices that have different trade-offs, the problem becomes how to choose Pareto-efficient solutions with respect to execution time and (monetary) cost to use the (CPU) resources. This paper proposes an algorithm to efficiently explore alternative CPU configurations for a given number of resources and identify Pareto-efficient solutions for cost and execution time trade-offs. The algorithm is evaluated through simulation using three different pricing models to charge for CPU provisioning according to the allocated CPU frequency and four widely used scientific workflow applications.

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.

Simulation of a workflow execution as a real Cloud by adding noise

Cloud computing provides a cheap and elastic platform for executing large scientific workflow applications, but it rises two challenges in prediction of makespan (total execution time): performance instability of Cloud instances and variant scheduling of dynamic schedulers. Estimating the makespan is necessary for IT managers in order to calculate the cost of execution, for which they can use Cloud simulators. However, the ideal simulated environment produces the same output for the same workflow schedule and input parameters and thus can not reproduce the Cloud variant behavior. In this paper, we define a model and a methodology to add a noise to the simulation in order to equalise its behavior with the Clouds’ one. We propose several metrics to model a Cloud fluctuating behavior and then by injecting them within the simulator, it starts to behave as close as the real Cloud. Instead of using a normal distribution naively by using mean value and standard deviation of workflow tasks’ runtime, we inject two noises in the tasks’ runtime: noisiness of tasks within a workflow (defined as average runtime deviation) and noisiness provoked by the environment over the whole workflow (defined as average environmental deviation). In order to measure the quality of simulation by quantifying the relative difference between the simulated and measured values, we introduce the parameter inaccuracy. A series of experiments with different workflows and Cloud resources were conducted in order to evaluate our model and methodology. The results show that the inaccuracy of the makespan’s mean value was reduced up to 59 times compared to naively using the normal distribution. Additionally, we analyse the impact of particular workflow and Cloud parameters, which shows that the Cloud performance instability is simulated more correctly for small instance type (inaccuracy of up to 11.5%), instead of medium (inaccuracy of up to 35%), regardless of the workflow. Since our approach requires collecting data by executing the workflow in the Cloud in order to learn its behavior, we conduct a comprehensive sensitivity analysis. We determine the minimum amount of data that needs to be collected or minimum number of test cases that needs to be repeated for each experiment in order to get less than 12% inaccuracy for our noising parameter. Additionally, in order to reduce the number of experiments and determine the dependency of our model against Cloud resource and workflow parameters, the conducted comprehensive sensitivity analysis shows that the correctness of our model is independent of workflow parallel section size. With our sensitivity analysis, we show that we can reduce the inaccuracy of the naive approach with only 40% of total number of executions per experiment in the learning phase. In our case, 20 executions per experiment instead of 50, and only half of all experiments, which means down to 20%, i.e. 120 test cases instead of 600.

A characterization of workflow management systems for extreme-scale applications

Automation of the execution of computational tasks is at the heart of improving scientific productivity. Over the last years, scientific workflows have been established as an important abstraction that captures data processing and computation of large and complex scientific applications. By allowing scientists to model and express entire data processing steps and their dependencies, workflow management systems relieve scientists from the details of an application and manage its execution on a computational infrastructure. As the resource requirements of today’s computational and data science applications that process vast amounts of data keep increasing, there is a compelling case for a new generation of advances in high-performance computing, commonly termed as extreme-scale computing, which will bring forth multiple challenges for the design of workflow applications and management systems. This paper presents a novel characterization of workflow management systems using features commonly associated with extreme-scale computing applications. We classify 15 popular workflow management systems in terms of workflow execution models, heterogeneous computing environments, and data access methods. The paper also surveys workflow applications and identifies gaps for future research on the road to extreme-scale workflows and management systems.

KGEN: A Python Tool for Automated Fortran Kernel Generation and Verification

Computational kernels, which are small pieces of software that selectively capture the characteristics of larger applications, have been used successfully for decades. Kernels allow for the testing of a compiler's ability to optimize code, performance of future hardware and reproducing compiler bugs. Unfortunately they can be rather time consuming to create and do not always accurately represent the full complexity of large scientific applications. Furthermore, expert knowledge is often required to create such kernels. In this paper, we present a Python-based tool that greatly simplifies the generation of computational kernels from Fortran based applications. Our tool automatically extracts partial source code of a larger Fortran application into a stand-alone executable kernel. Additionally, our tool also generates state data necessary for proper execution and verification of the extracted kernel. We have utilized our tool to extract more than thirty computational kernels from a million-line climate simulation model. Our extracted kernels have been used for a variety of purposes including: code modernization, identification of limitations in compiler optimizations, numerical algorithm debugging, compiler bug reporting, and for procurement benchmarking.

Using Compiler Directives to Port Large Scientific Applications to GPUs: An Example from Atmospheric Science

For many scientific applications, Graphics Processing Units (GPUs) can be an interesting alternative to conventional CPUs as they can deliver higher memory bandwidth and computing power. While it is conceivable to re-write the most execution time intensive parts using a low-level API for accelerator programming, it may not be feasible to do it for the entire application. But, having only selected parts of the application running on the GPU requires repetitively transferring data between the GPU and the host CPU, which may lead to a serious performance penalty. In this paper we assess the potential of compiler directives, based on the OpenACC standard, for porting large parts of code and thus achieving a full GPU implementation. As an illustrative and relevant example, we consider the climate and numerical weather prediction code COSMO (Consortium for Small Scale Modeling) and focus on the physical parametrizations, a part of the code which describes all physical processes not accounted for by the fundamental equations of atmospheric motion. We show, by porting three of the dominant parametrization schemes, the radiation, microphysics and turbulence parametrizations, that compiler directives are an efficient tool both in terms of final execution time as well as implementation effort. Compiler directives enable to port large sections of the existing code with minor modifications while still allowing for further optimizations for the most performance critical parts. With the example of the radiation parametrization, which contains the solution of a block tri-diagonal linear system, the required code modifications and key optimizations are discussed in detail. Performance tests for the three physical parametrizations show a speedup of between 3× and 7× for execution time obtained on a GPU and on a multi-core CPU of an equivalent generation.

Decision Support, Business Process Improvement and Managing Data

Information by itself is no longer perceived as an asset. Billions of business transactions are recorded in enterprise scale data warehouses every day. The acquisition, storage and management of business information are commonplace and often automated. Recent advances in (remote or other) sensor technologies have led to the development of scientific data repositories. Database technologies, ranging from relational systems, to extensions like spatial, temporal, time series, test or media as well as specialized tools like geographical systems (GIS) or on-line analytical processing (OLAP) have transformed the design of enterprise-scale business or large scientific applications. This paper attempts to briefly explain the Decision Support System and related concepts.

SMCV: a Methodology for Detecting Transient Faults in Multicore Clusters


 
 
 The challenge of improving the performance of current processors is achieved by increasing the integration scale. This carries a growing vulnerability to transient faults, which increase their impact on multicore clusters running large scientific parallel applications. The requirement for enhancing the reliability of these systems, coupled with the high cost of rerunning the application from the beginning, create the motivation for having specific software strategies for the target systems. This paper introduces SMCV, which is a fully distributed technique that provides fault detection for message-passing parallel applications, by validating the contents of the messages to be sent, preventing the transmission of errors to other processes and leveraging the intrinsic hardware redundancy of the multicore. SMCV achieves a wide robustness against transient faults with a reduced overhead, and accomplishes a trade-off between moderate detection latency and low additional workload.
 
 

A Hierarchical Load Balancing Policy for Grid Computing Environment

With the rapid development of high-speed wide-area networks and powerful yet low-cost computational resources, grid computing has emerged as an attractive computing paradigm. It provides resources for solving large scientific applications. It is typically composed of heterogeneous resources such as clusters or sites at different administrative domains connected by networks with widely varying performance characteristics. The service level of the grid software infrastructure provides two essential functions for workload and resource management. To efficiently utilize the resources at these environments, effective load balancing and resource management policies are fundamentally important. This paper addresses the problem of load balancing and task migration in grid computing environments. We propose a fully decentralized two-level load balancing policy for computationally intensive tasks on a heterogeneous multi-cluster grid environment. It resolves the single point of failure problem which many of the current policies suffer from. In this policy, any site manager receives two kinds of tasks namely, remote tasks arriving from its associated local grid manager, and local tasks submitted directly to the site manager by local users in its domain, which makes this policy closer to reality and distinguishes it from any other similar policy. It distributes the grid workload based on the resources occupation ratio and the communication cost. The grid overall mean task response time is considered as the main performance metric that need to be minimized. The simulation results show that the proposed load balancing policy improves the grid overall mean task response time.

Runtime and Programming Support for Memory Adaptation in Scientific Applications via Local Disk and Remote Memory

The ever increasing memory demands of many scientific applications and the complexity of today’s shared computational resources still require the occasional use of virtual memory, network memory, or even out-of-core implementations, with well known drawbacks in performance and usability. In Mills et al. (Adapting to memory pressure from within scientific applications on multiprogrammed COWS. In: International Parallel and Distributed Processing Symposium, IPDPS, Santa Fe, NM, 2004), we introduced a basic framework for a runtime, user-level library, MMlib, in which DRAM is treated as a dynamic size cache for large memory objects residing on local disk. Application developers can specify and access these objects through MMlib, enabling their application to execute optimally under variable memory availability, using as much DRAM as fluctuating memory levels will allow. In this paper, we first extend our earlier MMlib prototype from a proof of concept to a usable, robust, and flexible library. We present a general framework that enables fully customizable memory malleability in a wide variety of scientific applications. We provide several necessary enhancements to the environment sensing capabilities of MMlib, and introduce a remote memory capability, based on MPI communication of cached memory blocks between ‘compute nodes’ and designated memory servers. The increasing speed of interconnection networks makes a remote memory approach attractive, especially at the large granularity present in large scientific applications. We show experimental results from three important scientific applications that require the general MMlib framework. The memory-adaptive versions perform nearly optimally under constant memory pressure and execute harmoniously with other applications competing for memory, without thrashing the memory system. Under constant memory pressure, we observe execution time improvements of factors between three and five over relying solely on the virtual memory system. With remote memory employed, these factors are even larger and significantly better than other, system-level remote memory implementations.

Effectively utilizing global cluster memory for large data-intensive parallel programs

Large scientific parallel applications demand large amounts of memory space. Current parallel computing platforms schedule jobs without fully knowing their memory requirements. This leads to uneven memory allocation in which some nodes are overloaded. This, in turn, leads to disk paging, which is extremely expensive in the context of scientific parallel computing. To solve this problem, we propose a new peer-to-peer solution called parallel network RAM. This approach avoids the use of disk, better utilizes available RAM resources, and will allow larger problems to be solved while reducing the computational, communication, and synchronization overhead typically involved in parallel applications. We proposed several different parallel network RAM designs and evaluated the performance of each under different conditions. We discovered that different designs are appropriate in different situations.

Grid programming: some indications where we are headed

Grid computing enables the development of large scientific applications on an unprecedented scale. Grid-aware applications, also called meta-applications or multi-disciplinary applications, make use of coupled computational resources that are not available at a single site. In this light, the Grids let scientists solve larger or new problems by pooling together resources that could not be coupled easily before. It is well known that the programmer’s productivity in designing and implementing efficient distributed/parallel applications on high-performance computers is still usually a very time-consuming task. Grid computing makes the situation worse. Consequently, the development of Grid programming environments that would enable programmers to efficiently exploit this technology is an important and hot research issue. After an introduction on the main Grid programming issues, this paper will review the most important approaches/projects conducted in this field worldwide.

Managing Multiple Communication Methods in High-Performance Networked Computing Systems

Modern networked computing environments and applications often require—or can benefit from—the use of multiple communication substrates, transport mechanisms, and protocols, chosen according to where communication is directed, what is communicated, or when communication is performed. We propose techniques that allow multiple communication methods to be supported transparently in a single application, with either automatic or user-specified selection criteria guiding the methods used for each communication. We explain how communication link and remote service request mechanisms facilitate the specification and implementation of multimethod communication. These mechanisms have been implemented in the Nexus multithreaded runtime system, and we use this system to illustrate solutions to various problems that arise when multimethod communication is implemented. We also illustrate the application of our techniques by describing a multimethod, multithreaded implementation of the Message Passing Interface (MPI) standard, constructed by integrating Nexus with the Argonne MPICH library. Finally, we present the results of experimental studies that reveal performance characteristics of multimethod communication, the Nexus-based MPI implementation, and a large scientific application running in a heterogeneous networked environment.

Domain Decomposition and Schur Complement Approaches to Coupling the Well Equations in Reservoir Simulation

This note reports on the construction of preconditionings for bordered systems arising in compositional hydrocarbon reservoir modeling. The main portion of the system represents the reservoir equations, and the borders of the systems are associated with the production or injection constraints imposed on the active wells of the reservoir being modeled. In general, the simulation studies are sensitive to the accuracy of the solution at the wells. This note describes strategies for extending a reservoir preconditioning to the well terms. Three alternatives are considered including borrowing ideas from domain decomposition with one domain being the reservoir and the other domain being the well terms. The preconditioners were applied to several linear systems generated by a compositional reservoir simulator, which included various choices for the number of oil wells. The preconditioned iterative methods considered are MINRES and Bi-CGSTAB, which are variants of the conjugate gradient method. This note also reports the use of the Miranda functional programming language for a large scientific application.

Compositional Oil Reservoir Simulation in Fortran D: a Feasibility Study On Intel iPsc/860

This paper describes a study of the use of data-parallel languages such as Fortran D or High Performance For tran (HPF) and their compilation systems for existing large scientific applications. The central question ad dressed in this study is: Do such languages allow the parallelism available in the applications to be ex pressed so that the underlying compilation systems are able to generate efficient code for the specified parallelism? Our experiments on Intel's iPSC/860 distributed- memory multiprocessor indicate that the Fortran D lan guage and its compilation system can exploit the par allelism that exists in computations related to reservoir modeling, provided that the code is written in data- parallel programming style. Additional experiments show that other machines and their compilation sys tems can also exploit the compile time information available for programs written in a data-parallel pro gramming style.

An environment for parallel and distributed computation with application to overlapping grids

We describe an environment for efficient and scalable implementation of large scientific applications on parallel and distributed computing systems. We show how this environment is used to support overlapping grid methods. In addition to providing a user interface that reduces programming complexity, the environment facilitates dynamic partitioning of data and the scheduling of both computations and communication, transparent to the user. After describing the user interface and some of the implementation issues, we present performance data for a model application executed on two different systems: an eight-processor IBM Power Parallel Prototype (PPP) system and a 32-processor IBM POWER Visualization System™ (PVS).