High-performance Programming Research Articles

CauseMap: fast inference of causality from complex time series

Background. Establishing health-related causal relationships is a central pursuit in biomedical research. Yet, the interdependent non-linearity of biological systems renders causal dynamics laborious and at times impractical to disentangle. This pursuit is further impeded by the dearth of time series that are sufficiently long to observe and understand recurrent patterns of flux. However, as data generation costs plummet and technologies like wearable devices democratize data collection, we anticipate a coming surge in the availability of biomedically-relevant time series data. Given the life-saving potential of these burgeoning resources, it is critical to invest in the development of open source software tools that are capable of drawing meaningful insight from vast amounts of time series data.Results. Here we present CauseMap, the first open source implementation of convergent cross mapping (CCM), a method for establishing causality from long time series data (≳25 observations). Compared to existing time series methods, CCM has the advantage of being model-free and robust to unmeasured confounding that could otherwise induce spurious associations. CCM builds on Takens’ Theorem, a well-established result from dynamical systems theory that requires only mild assumptions. This theorem allows us to reconstruct high dimensional system dynamics using a time series of only a single variable. These reconstructions can be thought of as shadows of the true causal system. If reconstructed shadows can predict points from opposing time series, we can infer that the corresponding variables are providing views of the same causal system, and so are causally related. Unlike traditional metrics, this test can establish the directionality of causation, even in the presence of feedback loops. Furthermore, since CCM can extract causal relationships from times series of, e.g., a single individual, it may be a valuable tool to personalized medicine. We implement CCM in Julia, a high-performance programming language designed for facile technical computing. Our software package, CauseMap, is platform-independent and freely available as an official Julia package.Conclusions. CauseMap is an efficient implementation of a state-of-the-art algorithm for detecting causality from time series data. We believe this tool will be a valuable resource for biomedical research and personalized medicine.

English

Electrical power industry restricting has created highly vibrant and competitive market that altered many aspects of the power industry. In this changed scenario, scarcity of energy resources, increasing power generation cost, environment concern, ever growing demand of electrical energy necessitate optimal economic dispatch. Practical economic dispatch (ED) problems have nonlinear, non-convex type objective function with intense equality and inequality constraints. The conventional optimization methods are not able to solve such problems as due to local optimum solution convergence. This work proposes a novel metaheuristic optimization methodology aimed at solving economic dispatch problem considering valve point loading effects. The differential evolution (DE) may occasionally stop proceeding toward the global optimum even though the population has not converged to a local optimum. This situation is usually referred to as stagnation. DE also suffers from the problem of premature convergence, where the population converges to some local optima of a multimodal objective function, losing its diversity. Shuffled frog leaping algorithm (SFLA) is a newly developed memetic metaheuristic algorithm for combinatorial optimization, which has simple concept, few parameters, high performance, and easy programming. SFLA and its variants have been successfully applied to various fields of power system optimization. The proposed approach is based on a hybrid shuffled differential evolution (SDE) algorithm which combines the benefits of SFLA and DE.

THE ART AND SCIENCE OF GPU AND MULTI-CORE PROGRAMMING

This paper examines the computational programming issues that arise from the introduction of GPUs and multi-core computer systems. The discussions and analyses examine the implication of two principles (spatial and temporal locality) that provide useful metrics to guide programmers in designing and implementing efficient sequential and parallel application programs. Spatial and temporal locality represents a science of information flow and is relevant in the development of highly efficient computational programs. The art of high performance programming is to take combinations of these principles an d unravel the bottlenecks and latencies as sociate with the architecture for each manufacturer computer system, and develop appropriate coding and/or task scheduling schemes to mitigate or eliminate these latencies.

ScaleGPU: GPU Architecture for Memory-Unaware GPU Programming

Programmer-managed GPU memory is a major challenge in writing GPU applications. Programmers must rewrite and optimize an existing code for a different GPU memory size for both portability and performance. Alternatively, they can achieve only portability by disabling GPU memory at the cost of significant performance degradation. In this paper, we propose ScaleGPU, a novel GPU architecture to enable high-performance memory-unaware GPU programming. ScaleGPU uses GPU memory as a cache of CPU memory to provide programmers a view of CPU memory-sized programming space. ScaleGPU also achieves high performance by minimizing the amount of CPU-GPU data transfers and by utilizing the GPU memory's high bandwidth. Our experiments show that ScaleGPU can run a GPU application on any GPU memory size and also improves performance significantly. For example, ScaleGPU improves the performance of the hotspot application by ~48% using the same size of GPU memory and reduces its memory size requirement by ~75% maintaining the target performance.

Design and Development of Embedded Grinding Initiative Meter

For development of a high-performance grinding initiative Meter, this paper proposes an approach based on embedded system. The initiative Meter uses ARM9 microprocessor as hardware-platform and Windows CE 5.0 as operating system. It mainly describes the working principle and software and hardware design program in this article. It accelerates the speed of operation, enhances the real-time of measurement control, improves the measurement accuracy of initiative Meter through the adoption of high-performance microprocessor and multithreaded programming technology, and at the same time has good man-machine interface. The initiative Meter adopts touch screen operation, parameters of it can easily adjusted and set. According to the test, the embedded initiative Meter has a high performance in various aspects, it will have abroad market prospects for its higher ratio of performance to price.

Fast iterative graph computation with block updates

Scaling iterative graph processing applications to large graphs is an important problem. Performance is critical, as data scientists need to execute graph programs many times with varying parameters. The need for a high-level, high-performance programming model has inspired much research on graph programming frameworks. In this paper, we show that the important class of computationally light graph applications - applications that perform little computation per vertex - has severe scalability problems across multiple cores as these applications hit an early "memory wall" that limits their speedup. We propose a novel block-oriented computation model, in which computation is iterated locally over blocks of highly connected nodes, significantly improving the amount of computation per cache miss. Following this model, we describe the design and implementation of a block-aware graph processing runtime that keeps the familiar vertex-centric programming paradigm while reaping the benefits of block-oriented execution. Our experiments show that block-oriented execution significantly improves the performance of our framework for several graph applications.

Performance of Sediment Transport Simulations on NVIDIA's Kepler Architecture

Aiming to understand how high-performance CUDA programming can be done for NVIDIA's new Kepler architecture, we have investigated a specific case of simulating sediment transport. The arisen stencil computations have distinct features connected to the two nonlinear partial differential equations that constitute the mathematical model. Consequently, the required CUDA programming effort differs for the two corresponding CUDA kernel functions. While Kepler's new read-only data cache brings enough benefits for one kernel function, performance of the other kernel function is further enhanceable through using the shared memory and so-called halo threads. The highest achieved performance of the stencil computation amounts to 190.45 GFLOPs on a Tesla K20 GPU.

Library Faculty and Instructional Assessment: Creating a Culture of Assessment through the High Performance Programming Model of Organizational Transformation

In an environment in which libraries increasingly need to demonstrate their value to faculty and administrators, providing evidence of the library’s contribution to student learning through its instruction program is critical. However, building a culture of assessment can be a challenge, even if librarians recognize its importance. In order to lead change, coordinators of library instruction at institutions where librarians are also tenure-track faculty must build trust and collaboration, lead through influence, and garner support from administration for assessment initiatives. The purpose of this paper is to explore what it takes to build a culture of assessment in academic libraries where librarians are faculty through the High Performance Programming model of organizational change. The guidelines for building a culture of assessment will be exemplified by case studies at the authors’ libraries where instruction coordinators are using collaboration to build a culture of assessment with their colleagues.

Psychological Symptoms and Chronic Mood in Representative Samples of Elite Student-Athletes, Deselected Student-Athletes and Comparison Students

Stress-levels experienced by school-aged elite athletes are pronounced, but data on their mental health status are widely lacking. In our study, we examined self-reported psychological symptoms and chronic mood. Data from a representative sample of 866 elite student-athletes (aged 12–15 years), enrolled in high-performance sport programming in German Elite Schools of Sport, were compared with data from 80 student-athletes from the same schools who have just been deselected from elite sport promotion, and from 432 age- and sex-matched non-sport students from regular schools (without such programming). Anxiety symptoms were least prevalent in female elite student-athletes. In male elite student-athletes, only symptoms of posttraumatic stress were less prevalent than in the other groups. Somatoform symptoms were generally more frequent in athletes, a trend that was significantly pronounced in deselected athletes. Deselected athletes showed an increased risk for psychological symptoms compared with both other groups. Regarding chronic mood, again deselected athletes showed less positive scores. While there was a trend toward high-performance sport being associated with better psychological health at least in girls, preventative programs should take into account that deselection from elite sport programming may be associated with specific risks for mental disorders.

Towards High Performance and Usability Programming Methodology for Heterogeneous HPC Architectures

Towards High Performance and Usability Programming Methodology for Heterogeneous HPC Architectures

Improving performance of adaptive component-based dataflow middleware

Making the best use of modern computational resources for distributed applications requires expert knowledge of low-level programming tools, or a productive high-level and high-performance programming framework. Unfortunately, even state-of-the-art high-level frameworks still require the developer to conduct a tedious manual tuning step to find the work partitioning which gives the best application execution performance. Here, we present a novel framework, with which developers can easily create high-performance dataflow applications, without the tedious tuning process. We compare the performance of our approach to that of three distributed programming frameworks which differ significantly in their programming paradigm, their support for multi-core CPUs and accelerators, and their load-balancing approach. These three frameworks are DataCutter, a component-based dataflow framework, KAAPI, a framework using asynchronous function calls, and MR-MPI, a MapReduce implementation. By highly optimizing the implementations of three applications on the four frameworks and comparing the execution time performance of the runtime engines, we show their strengths and weaknesses. We show that our approach achieves good performance for a wide range of applications, with a much-reduced development cost.

Finding all solutions of separable systems of piecewise-linear equations using integer programming

Finding all solutions of nonlinear or piecewise-linear equations is an important problem which is widely encountered in science and engineering. Various algorithms have been proposed for this problem. However, the implementation of these algorithms are generally difficult for non-experts or beginners. In this paper, an efficient method is proposed for finding all solutions of separable systems of piecewise-linear equations using integer programming. In this method, we formulate the problem of finding all solutions by a mixed integer programming problem, and solve it by a high-performance integer programming software such as GLPK, SCIP, or CPLEX. It is shown that the proposed method can be easily implemented without making complicated programs. It is also confirmed by numerical examples that the proposed method can find all solutions of medium-scale systems of piecewise-linear equations in practical computation time.

A model‐based framework for building extensible, high performance stream processing middleware and programming language for IBM InfoSphere Streams

SUMMARYThis work presents an extensive case study on the model‐based design of a commercial‐grade stream processing middleware (IBM's InfoSphere Streams) its runtime and language (SPL) compiler. The model‐based underpinnings are pervasive throughout the whole environment, from describing inter‐process communication interfaces and objects to the design of the extensibility mechanism in the runtime and language. In addition to many software engineering advantages such as consistent, uniform, and self‐documented integration among the different parts of the system, we show intrinsic performance benefits to the platform derived from this design approach. First, we demonstrate how an incremental compilation strategy employed by the SPL compiler and rooted on the model description of the application, extracted by the compiler as part of the application building process, leads to better compile‐time performance. Second, we discuss how the model‐based code generation strategy employed by the SPL compiler also leads to increased runtime performance, by specializing the generated code to particular characteristics of the runtime environment. Finally, we show how the extensibility strategy used in the SPL language leads to automatic syntactic and semantic checks at compile time, while enabling behavioral reasoning and specific optimizations at runtime. Copyright © 2011 John Wiley & Sons, Ltd.

Simulation of operating characteristics of the silica gel–water adsorption chiller powered by solar energy

Abstract A lumped parameter model of a silica gel–water adsorption chiller driven by solar energy was introduced for the operating characteristics investigation. Matlab–Simulink, as a high-performance computing and programming tool, was used to simulate the operating characteristics of the chiller. Effects of the hot water tank capacity, the cycle time and the initial hot water temperature on the performance of the chiller were analyzed when the chiller was driven by a stable heat source and solar energy respectively. The simulation results indicated that when the chiller was driven by solar energy, the open circulation of the hot water with a short cycle time and the closed circulation of hot water with a longer cycle time were better. A proposal was also provided for the chiller driven by solar energy to work under the optimum working conditions, such as hot water circulation mode, cycle time and initial temperature.

Wisdom of crowds versus wisdom of linguists – measuring the semantic relatedness of words

AbstractIn this article, we present a comprehensive study aimed at computing semantic relatedness of word pairs. We analyze the performance of a large number of semantic relatedness measures proposed in the literature with respect to different experimental conditions, such as (i) the datasets employed, (ii) the language (English or German), (iii) the underlying knowledge source, and (iv) the evaluation task (computing scores of semantic relatedness, ranking word pairs, solving word choice problems). To our knowledge, this study is the first to systematically analyze semantic relatedness on a large number of datasets with different properties, while emphasizing the role of the knowledge source compiled either by the ‘wisdom of linguists’ (i.e., classical wordnets) or by the ‘wisdom of crowds’ (i.e., collaboratively constructed knowledge sources like Wikipedia).The article discusses benefits and drawbacks of different approaches to evaluating semantic relatedness. We show that results should be interpreted carefully to evaluate particular aspects of semantic relatedness. For the first time, we employ a vector based measure of semantic relatedness, relying on a concept space built from documents, to the first paragraph of Wikipedia articles, to English WordNet glosses, and to GermaNet based pseudo glosses. Contrary to previous research (Strube and Ponzetto 2006; Gabrilovich and Markovitch 2007; Zesch et al. 2007), we find that ‘wisdom of crowds’ based resources are not superior to ‘wisdom of linguists’ based resources. We also find that using the first paragraph of a Wikipedia article as opposed to the whole article leads to better precision, but decreases recall. Finally, we present two systems that were developed to aid the experiments presented herein and are freely available1 for research purposes: (i) DEXTRACT, a software to semi-automatically construct corpus-driven semantic relatedness datasets, and (ii) JWPL, a Java-based high-performance Wikipedia Application Programming Interface (API) for building natural language processing (NLP) applications.

Orchestrating Horizontal Parallelism and Vertical Instruction Packing of Programs to Improve System Overall Efficiency

Both performance and energy efficiency are critical concerns for embedded systems and portable devices. Multi-issue processors can exploit the instruction-level parallelism (ILP) of programs to improve the performance greatly, however, most of the time at a cost of energy and power consumption. How to reduce the energy consumption while maintaining the high performance of programs running on multi-issue processors remains a challenging problem. In this paper, we propose a novel approach to apply the instruction register file(IRF) technique from single-issue processor to VLIW architecture. Frequently executed instructions are selected to be placed in the on-chip IRF for fast and energy-efficient access in program execution. Violation of synchronization among VLIW instruction slots is avoided by introducing new instruction formats and microarchitectural support. The enhanced VLIW architecture is, thus, able to orchestrate the horizontal instruction parallelism and vertical instruction packing for programs to improve system overall efficiency. Our experimental results show that the proposed processor architecture achieves both the performance advantage provided by the VLIW architecture and high energy efficiency provided by the IRF-based instruction packing technique, e.g., the fetch energy consumption is reduced by 33.4 percent for a 4-way VLIW architecture with 16-entry IRFs for SPEC2000 testbenches.

D-MaPs - DNA-microarray projects: web-based software for multi-platform microarray analysis

The web application D-Maps provides a user-friendly interface to researchers performing studies based on microarrays. The program was developed to manage and process one- or two-color microarray data obtained from several platforms (currently, GeneTAC, ScanArray, CodeLink, NimbleGen and Affymetrix). Despite the availability of many algorithms and many software programs designed to perform microarray analysis on the internet, these usually require sophisticated knowledge of mathematics, statistics and computation. D-maps was developed to overcome the requirement of high performance computers or programming experience. D-Maps performs raw data processing, normalization and statistical analysis, allowing access to the analyzed data in text or graphical format. An original feature presented by D-Maps is GEO (Gene Expression Omnibus) submission format service. The D-MaPs application was already used for analysis of oligonucleotide microarrays and PCR-spotted arrays (one- and two-color, laser and light scanner). In conclusion, D-Maps is a valuable tool for microarray research community, especially in the case of groups without a bioinformatic core.

PEAK—a fast and effective performance tuning system via compiler optimization orchestration

Compile-time optimizations generally improve program performance. Nevertheless, degradations caused by individual compiler optimization techniques are to be expected. Feedback-directed optimization orchestration systems generate optimized code versions under a series of optimization combinations, evaluate their performance, and search for the best version. One challenge to such systems is to tune program performance quickly in an exponential search space. Another challenge is to achieve high program performance, considering that optimizations interact. Aiming at these two goals, this article presents an automated performance tuning system, PEAK , which searches for the best compiler optimization combinations for the important code sections in a program. The major contributions made in this work are as follows: (1) An algorithm called Combined Elimination (CE) is developed to explore the optimization space quickly and effectively; (2) Three fast and accurate rating methods are designed to evaluate the performance of an optimized code section based on a partial execution of the program; (3) An algorithm is developed to identify important code sections as candidates for performance tuning by trading off tuning speed and tuned program performance; and (4) A set of compiler tools are implemented to automate optimization orchestration. Orchestrating optimization options in SUN Forte compilers at the whole-program level, our CE algorithm improves performance by 10.8% over the SPEC CPU2000 FP baseline setting, compared to 5.6% improved by manual tuning. Orchestrating GCC O3 optimizations, CE improves performance by 12% over O3, the highest optimization level. Applying the rating methods, PEAK reduces tuning time from 2.19 hours to 5.85 minutes on average, while achieving equal or better program performance.

Parallel Languages and Compilers: Perspective From the Titanium Experience

We describe the rationale behind the design of key features of Titanium—an explicitly parallel dialect of Java for high-performance scientific programming—and our experiences in building applications with the language. Specifically, we address Titanium's partitioned global address space model, single program multiple data parallelism support, multi-dimensional arrays and array-index calculus, memory management, immutable classes (class-like types that are value types rather than reference types), operator overloading, and generic programming. We provide an overview of the Titanium compiler implementation, covering various parallel analyses and optimizations, Titanium runtime technology and the GASNet network communication layer. We summarize results and lessons learned from implementing the NAS parallel benchmarks, elliptic and hyperbolic solvers using adaptive mesh refinement, and several applications of the immersed boundary method.

PERFORMANCE EVALUATION OF BLAS ON THE TRIDENT PROCESSOR

Different subtasks of an application usually have different computational, memory, and I/O requirements that result in different needs for computer capabilities. Thus, the more appropriate approach for both high performance and simple programming model is designing a processor having multi-level instruction set architecture (ISA). This leads to high performance and minimum executable code size. Since the fundamental data structures for a wide variety of existing applications are scalar, vector, and matrix, our research Trident processor has three-level ISA executed on zero-, one-, and two-dimensional arrays of data. These levels are used to express a great amount of fine-grain data parallelism to a processor instead of the dynamical extraction by a complicated logic or statically with compilers. This reduces the design complexity and provides high-level programming interface to hardware. In this paper, the performance of Trident processor is evaluated on BLAS, which represent the kernel operations of many data parallel applications. We show that Trident processor proportionally reduces the number of clock cycles per floating-point operation by increasing the number of execution datapaths.