THEMIS Component Dependence Metadata in Adaptive Parallel Applications

<p>Nowadays one of the main challenges in scientific computational field is developing the next<br>generation of HPC technologies, applications and systems towards exascale. This leads to focus the<br>efforts on the development of a new, efficient, stable and scalable NEMO reference code with<br>improved performances adapted to exploit future HPC technologies in the context of CMEMS systems.<br>On the main factors that limit the current scalability is an inefficient exploitation of the single node<br>performance. Different technical solutions have been tested to fully exploit memory hierarchies and<br>hardware peak performance. Between all, the fusion of DO loops together and by dividing the<br>computation over tiles are the two optimization strategies more efficiently take advantage of the<br>cache memory organization. This work focuses on the first one.<br>The loop fusion is a transformation which takes two adjacent loops that have the same iteration space<br>traversal and combines their bodies into a single loop. This optimization improves data locality so<br>giving a better exploitation of the cache memory and a reduction of the memory footprint because the<br>temporary arrays can be replaced with scalar values.<br>Performance tests have been executed on a domain size of 3002x2002x31 grid points running 1-year<br>GYRE_PISCES simulations with IO disabled on the Zeus Intel Xeon Gold 6154 machine, available at<br>CMCC. An increasing number of cores - from 504 to 2016 – have been used to test experiments with<br>the different HPC options.<br>The analysis focused on the routines where the optimizations have been applied. The use of the<br>extended halo introduces a penalty in the execution time that grows as the number of processes<br>increases and generally the use of loop fusion optimization slightly improves the performance. For<br>many routines, as subdomains get smaller, the improvements due to optimizations are less significant.<br>The simultaneous application of all optimizations leads to an improvement between 10% and 50%<br>(except for lateral diffusion). Looking at the total elapsed time, the new HPC optimizations speed up </p><p>the elapsed time of a factor 1.25x. Unfortunately, non-optimized routines mitigate this improvement.</p><p>The same scalability test has been repeated running 1-month ORCA025 simulations with the output<br>set to be produced at the end of the run. The results show that the use of loop fusion optimization<br>slightly improves the performance. The use of tiling in ORCA025 introduces less benefits with<br>reference to GYRE. The simultaneous application of all optimizations doesn't lead many benefits in<br>ORCA025 since the improvement concerns only a subset of routines with the Tracer lateral diffusion<br>routine getting worse in all cases.<br>In conclusion the impact of the new optimized code behaves differently depending on the<br>configuration. The overhead introduced by the extended halo implies a computation time cost that the<br>proposed optimizations are able to regain difficultly. Tiling is the aspect with the highest impact in<br>these optimizations (especially in GYRE) and loop fusion has in general a low impact. The optimizations<br>should be applied to all the rest of the code to obtain more benefits.</p>

The challenges of the Big Data era has motivated many organizations to turn towards distributed, large-scale processing platforms to deal with their data. Map Reduce, and its open-source implementation, Hadoop, has grown to be highly popular with its successful programming model for simplified cluster processing. As a result, many organizations deploy their own Map Reduce/Hadoop clusters to store and process large amounts of useful data. This multicluster setting is gradually growing attention. Numerous previous works have researched on how to execute Map Reduce across geographically distributed data in this setting. However, an important class of applications have not been explored for multicluster Map Reduce: iterative computation. In this paper, we propose Fed Loop, a composite system aimed at providing iterative Map Reduce computation for geographically distributed data in multicluster settings. Fed Loop is capable of transparently executing both iterative and non-iterative Map Reduce jobs on either a single cluster or multiple clusters. For our performance evaluation, two well-known iterative algorithms was executed over 4 independent clusters (16 physical nodes in total) using Fed Loop: K-Means and Page Rank. Results helped us discover how different iterative applications may differ in execution efficiency for mutlicluster environments and how iterative multicluster computation systems like Fed Loop can be optimized.

In this paper has been considered the main content and distinctive features of the “Geometric Modeling” training course for the “Mathematics and Computer Science” training program 02.03.01 (“Mathematical and Computer Modeling” specialization).
 The goal of the “Geometric Modeling” course study is the assimilation of mathematical methods for construction of geometric objects with complex curved shapes, and techniques for their computer visualization by using polygons of curves and surfaces. Methods for construction of structures’ curved shapes using spline representations, as well as techniques for construction of surfaces and volumetric geometries using motion operations and basic logical operations on geometric objects are considered. The spline representations include linear and bilinear splines, Hermite cubic splines and Hermite surfaces, natural cubic and bicubic interpolation splines, Bezier curves and surfaces, rational Bezier splines, B-splines and B-spline surfaces, NURBS-curves and NURBS-surfaces, transfinite interpolation methods, and splines of surfaces with triangular form. Logical operations for intersection of two spline curves, and intersection of two parametric surfaces are considered. The principles of scientific visualization and computer animation are considered in this course as well.
 Some examples for visualization of initial data and results of curves and surfaces construction in two- and three-dimensional spaces through the software shell developed by authors and used by students while doing tests have been demonstrated. The software shell has a web interface with the WebGL library graphic support. Tasks for four practical studies in a computer classroom, as well as several variations of homework are represented.
 The problems occurring in preparation materials for some course sections are discussed, as well as the practical importance of acquired knowledge for the further progress of students.
 The paper may be interesting for teachers of “Geometric Modeling” and “Computer Graphics” courses aimed to students with a specialization in mathematics and information, as well as to those who independently develop software interfaces for algorithms of geometric modeling.

SummaryOpenACC is a directive‐based programming model which allows programmers to write graphic processing unit (GPU) programs by simply annotating parallel loops. However, OpenACC has poor support for irregular nested parallel loops, which are natural choices to express nested parallelism. We propose PFACC, a programming model similar to OpenACC. PFACC directives can be used to annotate parallel loops and to guide data movement between different levels of memory hierarchy. Parallel loops can be arbitrarily nested or be placed inside functions that would be (possibly recursively) called in other parallel loops. The PFACC translator translates C programs with PFACC directives into CUDA programs by inserting runtime iteration‐sharing and memory allocation routines. The PFACC runtime iteration‐sharing routine is a two‐level mechanism. Thread blocks dynamically organize loop iterations into batches and execute the batches in a depth‐first order. Different thread blocks share iterations among one another with an iteration‐stealing mechanism. PFACC generates CUDA programs with reasonable memory usage because of the depth‐first execution order. The two‐level iteration‐sharing mechanism is implemented purely in software and fits well with the CUDA thread hierarchy. Experiments show that PFACC outperforms CUDA dynamic parallelism in terms of performance and code size on most benchmarks.

This paper shows how to compile sparse array programming languages. A sparse array programming language is an array programming language that supports element-wise application, reduction, and broadcasting of arbitrary functions over dense and sparse arrays with any fill value. Such a language has great expressive power and can express sparse and dense linear and tensor algebra, functions over images, exclusion and inclusion filters, and even graph algorithms. Our compiler strategy generalizes prior work in the literature on sparse tensor algebra compilation to support any function applied to sparse arrays, instead of only addition and multiplication. To achieve this, we generalize the notion of sparse iteration spaces beyond intersections and unions. These iteration spaces are automatically derived by considering how algebraic properties annotated onto functions interact with the fill values of the arrays. We then show how to compile these iteration spaces to efficient code. When compared with two widely-used Python sparse array packages, our evaluation shows that we generate built-in sparse array library features with a performance of 1.4× to 53.7× when measured against PyData/Sparse for user-defined functions and between 0.98× and 5.53× when measured against SciPy/Sparse for sparse array slicing. Our technique outperforms PyData/Sparse by 6.58× to 70.3×, and (where applicable) performs between 0.96× and 28.9× that of a dense NumPy implementation, on end-to-end sparse array applications. We also implement graph linear algebra kernels in our system with a performance of between 0.56× and 3.50× compared to that of the hand-optimized SuiteSparse:GraphBLAS library.

Improving data locality in programs which manipulate arrays has been the subject of a great deal of research. Much of the work on improving data locality examines individual loop nests; other work includes transformations such as loop fusion, which combines loops so that multiple loop nests can be transformed as a single loop nest. We propose a data-driven method to optimize locality across multiple loop nests. Our technique achieves loop fusion-like results even when normal loop fusion is illegal without enabling transformations. Given an array whose locality should be optimized, it also finds other calculations that can profitably be executed with the computation of that array.KeywordsTransitive ClosureArray ElementIteration SpaceLoop NestInnermost LoopThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The authors present an integrated approach to compiling Fortran 77D and Fortran 90D programs for efficient execution on MIMD (multiple-instruction multiple-data) distributed-memory machines. the integrated Fortran D compiler relies on two key observations. First, array constructs may be scalarized into FORALL loops without loss of information. Second, loop fusion, partitioning, and sectioning optimizations are essential for both Fortran D dialects. A portable run-time library can also reduce the complexity and machine-dependence of the compiler. All optimizations except coarse-grain pipelining and data prefetching have been implemented in the current Fortran D compiler prototype. >

It is expected that the first exascale supercomputer will be deployed within the next 10 years, but which programming model will allow easy development and yet scalable and efficient programs is still not known. One of the programming models considered to be feasible is the so-called partitioned global address space~(PGAS) model, which allows easy development by providing one common memory address space across all cluster nodes. In this paper we compare remote memory access and memory consistency of current PGAS programming languages and describe how synchronization can generated unneeded network transfers. We furthermore introduce our variation of the PGAS model that allows for implicit fine-grained pair-wise synchronization among the nodes. Efficient and easy to use synchronization is necessary to keep all the processors of upcoming supercomputers busy. We furthermore offer easy deployment of RDMA transfers and use communication algorithms commonly used in MPI collective operations, but lift the requirement of the operations to be collective. Our model is based on single assignment variables and uses a data-flow like synchronization mechanism. Reading uninitialized variables results in the reading thread to be blocked until data are made available by another thread. That way synchronization is done implicitly when data are read. Broadcast, scatter and gather are modeled based on data distribution among the nodes, whereas for reduction and scan we follow a combining PRAM approach of having multiple threads write to the same memory location. We discuss both a Gaus-Seidel stencil and bitonic sort in our model. We implemented a proof-of-concept library showing the usability and scalability of the model. With this library the Gaus-Seidel stencil scaled well in initial experiments on an 8-node machine.

The Renoir Dataflow Platform: Efficient Data Processing without Complexity

The paper begins by considering what a grid computing environment might be, why it is demanded and how the authors' HP spmd programming fits into this picture. We then review our HP Java environment as a contribution towards programming support for high-performance grid-enabled environments. Future grid computing systems will need to provide programming models. In a proper programming model for grid-enabled environments and applications, high performance on multi-processor systems is a critical issue. We describe the features of HP Java, including run-time communication library, compilation strategies and optimization schemes. Through experiments, we compare HP Java programs against FORTRAN and ordinary Java programs. We aim to demonstrate that HP Java can be used “anywhere”—not only for high-performance parallel computing, but also for grid-enabled applications.

As a programming model, MapReduce is implied for easier processing and generating large cluster of distributed data sets. We use CSP framework to model MapReduce system through which the parallelization of the computation and the distribution of data across multiple machines can be reflected. Some properties of MapReduce can be verified based on the achieved model.

Licenses are important for open government data (OGD) distribution for the purpose of reducing legal uncertainties and increasing data interoperability, especially in linked open data applications. Many standard licenses and open licenses have been created by national governments and OGD organizations to use with the publication and dissemination of OGD. Using a content analysis method, this study examines the U.S. state-level OGD licensing policies and practices. Results show that most state-level governments have OGD policies in the form of formal legislation, executive order, data policy, or terms of use/legal disclaimer, but only twenty-one states have licensing-related policies. Licenses, including a variety of standard open licenses and local custom licenses (most of which are not open licenses), are adopted by more than half of the state portals. The licensing practices are generally consistent with the licensing policies, but inconsistencies can also be identified. The study calls for the state governments to prioritize their OGD licensing policies and practices.KeywordsOpen government dataLicensing of Open DataPublic domainCreative Commons LicenseLinked open data

Modeling and programming parallel applications is becoming unavoidable for next generation of software architects and programmers, owing to the popularization of multi-core processors. ParDT is a graphical model-driven development toolsuite which supports not only modeling of parallel programs on high abstraction level but the translation of the constructed models into source code skeletons according to the specific runtime environments and libraries. The process of translation, which involves the parsing of graphical models and the generation of source code skeletons aimed at different parallel platforms, are explained in detail. ParDT is implemented based on Eclipse and compatible with its plug-in architecture. The toolsuite manages to help programmers relieve the burden of building parallel applications.

Optimization of loop-network reconfiguration strategies to eliminate transmission line overloads in power system restoration process with wind power integration

In this work, a practical implementation of two parallel thinning algorithms on a multicomputer system are described. The solution has been conceived for a multiprocessor using the SPMD (single program multiple data) programming model. Our main goal is intended to describe our experiences on data partition/distribution among processors for parallel thinning algorithms as a representative type of algorithm where communications take place between neighbor processors and the work load for each processor depends on the input data. It will be shown how the efficiency of the parallel implementation can be improved through the application of a preprocess. This preprocess is based on the analysis of the work load balance. An analysis of the communication cost is also made. Although the results shown here are concerned with the implementations of two parallel thinning algorithms we think that our proposal about data distribution is general and useful for a wide set of algorithms in the field of image processing. Copyright © 2000 John Wiley & Sons, Ltd.