High-performance Programming Research Articles

Cpp-Taskflow: A General-Purpose Parallel Task Programming System at Scale

This article introduces Cpp-Taskflow, a high-performance parallel task programming system, to streamline the building of large and complex parallel applications. Cpp-Taskflow leverages the power of modern C++ and task-based approaches to enable efficient implementations of parallel decomposition strategies. Our programming model can quickly handle not only traditional loop-level parallelism but also irregular patterns, such as graph algorithms and dynamic control flows. Compared with existing libraries, Cpp-Taskflow is more cost efficient in performance scaling and software integration. We have evaluated Cpp-Taskflow on both micro-benchmarks and large-scale design automation problems of million-scale tasking. In a particular timing analysis workload, Cpp-Taskflow outperformed OpenMP by 2× faster using 2× fewer lines of code. We have also shown Cpp-Taskflow achieved up to 47.81% speed-up with 28.5% less code over the industrial-strength library, Intel Threading Building Blocks, on a detailed placement problem.

TIP_finder: An HPC Software to Detect Transposable Element Insertion Polymorphisms in Large Genomic Datasets.

Transposable elements (TEs) are non-static genomic units capable of moving indistinctly from one chromosomal location to another. Their insertion polymorphisms may cause beneficial mutations, such as the creation of new gene function, or deleterious in eukaryotes, e.g., different types of cancer in humans. A particular type of TE called LTR-retrotransposons comprises almost 8% of the human genome. Among LTR retrotransposons, human endogenous retroviruses (HERVs) bear structural and functional similarities to retroviruses. Several tools allow the detection of transposon insertion polymorphisms (TIPs) but fail to efficiently analyze large genomes or large datasets. Here, we developed a computational tool, named TIP_finder, able to detect mobile element insertions in very large genomes, through high-performance computing (HPC) and parallel programming, using the inference of discordant read pair analysis. TIP_finder inputs are (i) short pair reads such as those obtained by Illumina, (ii) a chromosome-level reference genome sequence, and (iii) a database of consensus TE sequences. The HPC strategy we propose adds scalability and provides a useful tool to analyze huge genomic datasets in a decent running time. TIP_finder accelerates the detection of transposon insertion polymorphisms (TIPs) by up to 55 times in breast cancer datasets and 46 times in cancer-free datasets compared to the fastest available algorithms. TIP_finder applies a validated strategy to find TIPs, accelerates the process through HPC, and addresses the issues of runtime for large-scale analyses in the post-genomic era.

MENDESAIN MULTIMEDIA PEMBELAJARA DESIGN THE MULTIMEDIA LEARNING OF MATHEMATICS USING GUI MATLAB

GUI (Graphical User Interface) is a MATLAB tool as multimedia or a tool that can be used in learning mathematics. MATLAB is a high-performance programming language for computing science or mathematical problems. MATLAB integrates computation, algorithm building, data acquisition, modeling, simulation and prototyping, data analysis, exploration, visualization. The GUI toolbox available in MATLAB can be used to build multimedia applications for learning mathematics. With graphic objects such as buttons, text boxes, sliders, menus and others, it helps someone design mathematics learning media as desired.

SnakeStrike: A Low-Cost Open-Source High-Speed Multi-Camera Motion Capture System.

Current neuroethological experiments require sophisticated technologies to precisely quantify the behavior of animals. In many studies, solutions for video recording and subsequent tracking of animal behavior form a major bottleneck. Three-dimensional (3D) tracking systems have been available for a few years but are usually very expensive and rarely include very high-speed cameras; access to these systems for research is limited. Additionally, establishing custom-built software is often time consuming – especially for researchers without high-performance programming and computer vision expertise. Here, we present an open-source software framework that allows researchers to utilize low-cost high-speed cameras in their research for a fraction of the cost of commercial systems. This software handles the recording of synchronized high-speed video from multiple cameras, the offline 3D reconstruction of that video, and a viewer for the triangulated data, all functions previously also available as separate applications. It supports researchers with a performance-optimized suite of functions that encompass the entirety of data collection and decreases processing time for high-speed 3D position tracking on a variety of animals, including snakes. Motion capture in snakes can be particularly demanding since a strike can be as short as 50 ms, literally twice as fast as the blink of an eye. This is too fast for faithful recording by most commercial tracking systems and therefore represents a challenging test to our software for quantification of animal behavior. Therefore, we conducted a case study investigating snake strike speed to showcase the use and integration of the software in an existing experimental setup.

A comparative study of high-productivity high-performance programming languages for parallel metaheuristics

Parallel metaheuristics require programming languages that provide both, high performance and a high level of programmability. This paper aims at providing a useful data point to help practitioners gauge the difficult question of whether to invest time and effort into learning and using a new programming language. To accomplish this objective, three productivity-aware languages (Chapel, Julia, and Python) are compared in terms of performance, scalability and productivity. To the best of our knowledge, this is the first time such a comparison is performed in the context of parallel metaheuristics. As a test-case, we implement two parallel metaheuristics in three languages for solving the 3D Quadratic Assignment Problem (Q3AP), using thread-based parallelism on a multi-core shared-memory computer. We also evaluate and compare the performance of the three languages for a parallel fitness evaluation loop, using four different test-functions with different computational characteristics. Besides providing a comparative study, we give feedback on the implementation and parallelization process in each language.

HPIPM: a high-performance quadratic programming framework for model predictive control

This paper introduces HPIPM, a high-performance framework for quadratic programming (QP), designed to provide building blocks to efficiently and reliably solve model predictive control problems. HPIPM currently supports three QP types, and provides interior point method (IPM) solvers as well (partial) condensing routines. In particular, the IPM for optimal control QPs is intended to supersede the HPMPC solver, and it largely improves robustness while keeping the focus on speed. Numerical experiments show that HPIPM reliably solves challenging QPs, and that it outperforms other state-of-the-art solvers in speed.

OpEn: Code Generation for Embedded Nonconvex Optimization

We present Optimization Engine (OpEn): an open-source code generation framework for real-time embedded nonconvex optimization, which implements a novel numerical method. OpEn combines the proximal averaged Newton-type method for optimal control (PANOC) with the penalty and augmented Lagrangian methods to compute approximate stationary points of nonconvex problems. The proposed method involves very simple algebraic operations such as vector products, has a low memory footprint and exhibits very good convergence properties that allow the solution of nonconvex problems on embedded devices. OpEn’s core solver is written is Rust — a modern, high-performance, memory-safe and thread-safe systems programming language — while users can call it from Python, MATLAB, C, C++, ROS or over a TCP socket.

Research on Synchronization Mechanism of Parallel Time Propulsion Based on ABMS Overlap Area

Abstract The paper proposes a parallel time advance synchronization mechanism based on the overlap region of ABMS (Agent-based Modeling and Simulation). It is driven by events. Combines with the ABMS overlap region, it could ensure the correct execution event causal logic relationship and improve the simulation parallelism and simulation rate. The simulation results shows that the mechanism could be implemented on the X10 high-performance programming language and obtains a good acceleration effect.

Finding all solution sets of piecewise-linear interval equations using an integer programming solver

This paper presents an efficient and easily implementable method for finding all solution sets of piecewise-linear interval equations using integer programming. In this method, the problem of finding all solution sets is formulated as a mixed integer programming problem, and it is solved by a high-performance integer programming solver such as CPLEX. It is shown that all solution sets are obtained by solving a single mixed integer programming problem and related linear programming problems. Numerical examples are given to confirm the effectiveness of the proposed method.

A fast parallel genetic programming framework with adaptively weighted primitives for symbolic regression

Genetic programming (GP) is a popular and powerful optimization algorithm that has a wide range of applications, such as time series prediction, classification, data mining, and knowledge discovery. Despite the great success it enjoyed, selecting the proper primitives from high-dimension primitive set for GP to construct solutions is still a time-consuming and challenging issue that limits the efficacy of GP in real-world applications. In this paper, we propose a multi-population GP framework with adaptively weighted primitives to address the above issues. In the proposed framework, the entire population consists of several sub-populations and each has a different vector of primitive weights to determine the probability of using the corresponding primitives in a sub-population. By adaptively adjusting the weights of the primitives and periodically sharing information between sub-populations, the proposed framework can efficiently identify important primitives to assist the search. Furthermore, based on the proposed framework and the graphics processing unit computing technique, a high-performance self-learning gene expression programming algorithm (HSL-GEP) is developed. The HSL-GEP is tested on fifteen problems, including four real-world problems. The experimental results have demonstrated that the proposed HSL-GEP outperforms several state-of-the-art GPs, in terms of both solution quality and search efficiency.

Large-scale Agent Data Partitioning Based on DensityRepel-K_medoids

Large-scale Agent data partitioning is the premise of parallel distributed computing in the process of ABMS (Agent-based Modeling and Simulation) . Based on the distance-based K_medoids clustering algorithm, this paper proposes an improved K_medoids algorithm (DensityRepel-K_medoids), which is implemented by high-performance programming language X10 and applied to large-scale Agent data partitioning simulation based on distance interaction. The DensityRepel-Kmedoids algorithm first determines the density value and the repulsion value of each Agent data in the Agent data set, and secondly pre-selects the cluster center according to the density value and the repulsion value of each Agent data, and finally uses the pre-selected cluster centers as the initial cluster centers for continuous iterative clustering until convergence. The algorithm avoids the defects of K_means clustering algorithm sensitive to outliers, and avoids the shortcomings of K_medoids clustering algorithm for large-scale data processing. By comparing and analyzing the simulation experiments of Agent data sets of different scales, the algorithm presents a better performance.

BioSimulator.jl: Stochastic simulation in Julia

Background and Objectives: Biological systems with intertwined feedback loops pose a challenge to mathematical modeling efforts. Moreover, rare events, such as mutation and extinction, complicate system dynamics. Stochastic simulation algorithms are useful in generating time-evolution trajectories for these systems because they can adequately capture the influence of random fluctuations and quantify rare events. We present a simple and flexible package, BioSimulator.jl, for implementing the Gillespie algorithm, τ-leaping, and related stochastic simulation algorithms. The objective of this work is to provide scientists across domains with fast, user-friendly simulation tools.Methods: We used the high-performance programming language Julia because of its emphasis on scientific computing. Our software package implements a suite of stochastic simulation algorithms based on Markov chain theory. We provide the ability to (a) diagram Petri Nets describing interactions, (b) plot average trajectories and attached standard deviations of each participating species over time, and (c) generate frequency distributions of each species at a specified time.Results: BioSimulator.jl’s interface allows users to build models programmatically within Julia. A model is then passed to the simulate routine to generate simulation data. The built-in tools allow one to visualize results and compute summary statistics. Our examples highlight the broad applicability of our software to systems of varying complexity from ecology, systems biology, chemistry, and genetics.Conclusion: The user-friendly nature of BioSimulator.jl encourages the use of stochastic simulation, minimizes tedious programming efforts, and reduces errors during model specification.

Development of a Program Definition Rating Index for the Performance Prediction of Construction Programs

Program management is the structured and strategic process of managing multiple projects at a high level to maximize benefits. The essentials of programs include high costs and long implementation periods, and thus, the negative impacts caused by the failure of program management are more significant and greater than that of a project. Therefore, to achieve high program performance, it is essential for program management to be well defined during the early stages. However, the existing research is mainly focused on the performance prediction methodologies for projects, while the research pertaining to programs has concentrated on identifying the qualitative critical success factors (CSFs). Thus, this study developed a methodology for predicting the program performance. Forty-five CSFs were identified herein from literature review and expert interviews, then grouped through factor analysis. In addition, the Program Definition Rating Index (PgDRI) was developed by calculating the weights of the proposed CSFs through structured equation modeling in order to evaluate the quantitative program performance. For validation, the PgDRI was applied to three in-progress cases, and the PgDRI scores were compared with the actual performance of each case. The PgDRI developed in this study can contribute to the body of knowledge pertaining to program management by quantifying the performance management of a program. In addition, the PgDRI can be utilized in the performance management of a program in terms of the cost and schedule by allowing practitioners to apply the PgDRI repeatedly to the major decision-making processes during the early stages of a program.

Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools

Context: Software development tools that interact with running programs such as debuggers, profilers, and dynamic analysis frameworks are presumed to demand difficult tradeoffs among implementation complexity (cost), functionality, usability, and performance. Among the many consequences, tools are often delivered late (if ever), have limited functionality, require non-standard configurations, and impose serious performance costs on running programs. Inquiry: Can flexible tool support become a practical, first class, intrinsic requirement for a modern highperformance programming language implementation framework? Approach: We extended the Truffle Language Implementation Framework, which together with the GraalVM execution environment makes possible very high performance language implementations. Truffle's new Instrumentation Framework is language-agnostic and designed to derive high performance from the same technologies as do language implementations. Truffle Instrumentation includes: (1) low overhead capture of execution events by dynamically adding "wrapper" nodes to executing ASTs; (2) extensions to the Language Implementation Framework that allow per-language specialization, primarily for visual display of values and names, among others; and (3) versatile APIs and support services for implementing many kinds of tools without VM modification. Knowledge: It is now possible for a client in a production environment to insert (dynamically, with thread safety) an instrumentation probe that captures and reports abstractly specified execution events. A probe in fully optimized code imposes very low overhead until actually used to access (or modify) execution state. Event capture has enabled construction of numerous GraalVM services and tools that work for all implemented languages, either singly or in combination. Instrumentation has also proved valuable for implementing some traditionally tricky language features, as well as some GraalVM services such as placing bounds on resources consumed by running programs. Grounding: Tools for debugging (via multiple clients), profiling, statement counting, dynamic analysis, and others are now part of GraalVM or are in active development. Third parties have also used Truffle Instrumentation for innovative tool implementations. Importance: Experience with Truffle Instrumentation validates the notion that addressing developer tools support as a forethought can change expectations about the availability of practical, efficient tools for high-performance languages. Tool development becomes a natural part of language implementation, requiring little additional effort and offering the advantage of early and continuous availability.

SeqArray-a storage-efficient high-performance data format for WGS variant calls.

Whole-genome sequencing (WGS) data are being generated at an unprecedented rate. Analysis of WGS data requires a flexible data format to store the different types of DNA variation. Variant call format (VCF) is a general text-based format developed to store variant genotypes and their annotations. However, VCF files are large and data retrieval is relatively slow. Here we introduce a new WGS variant data format implemented in the R/Bioconductor package 'SeqArray' for storing variant calls in an array-oriented manner which provides the same capabilities as VCF, but with multiple high compression options and data access using high-performance parallel computing. Benchmarks using 1000 Genomes Phase 3 data show file sizes are 14.0 Gb (VCF), 12.3 Gb (BCF, binary VCF), 3.5 Gb (BGT) and 2.6 Gb (SeqArray) respectively. Reading genotypes in the SeqArray package are two to three times faster compared with the htslib C library using BCF files. For the allele frequency calculation, the implementation in the SeqArray package is over 5 times faster than PLINK v1.9 with VCF and BCF files, and over 16 times faster than vcftools. When used in conjunction with R/Bioconductor packages, the SeqArray package provides users a flexible, feature-rich, high-performance programming environment for analysis of WGS variant data. http://www.bioconductor.org/packages/SeqArray. zhengx@u.washington.edu. Supplementary data are available at Bioinformatics online.

Programming the material point method in Julia

This article presents the implementation of the material point method (MPM) using Julia. Julia is an open source, multi-platform, high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to Matlab and Python programmers. MPM is a hybrid particle-grid approach that combines the advantages of Eulerian and Lagrangian methods and is suitable for complex solid mechanics problems involving contact, impact and large deformations. We will show that a Julia based MPM code, which is short, compact and readable and uses only Julia built in features, performs much better (with speed up of up to 8) than a similar Matlab based MPM code for large strain solid mechanics simulations. We share our experiences of implementing MPM in Julia and demonstrate that Julia is a very interesting platform for rapid development in the field of scientific computing.

Code cache management in managed language VMs to reduce memory consumption for embedded systems

The compiled native code generated by a just-in-time (JIT) compiler in managed language virtual machines (VM) is placed in a region of memory called the code cache. Code cache management (CCM) in a VM is responsible to find and evict methods from the code cache to maintain execution correctness and manage program performance for a given code cache size or memory budget. Effective CCM can also boost program speed by enabling more aggressive JIT compilation, powerful optimizations, and improved hardware instruction cache and I-TLB performance. Though important, CCM is an overlooked component in VMs. We find that the default CCM policies in Oracle’s production-grade HotSpot VM perform poorly even at modest memory pressure. We develop a detailed simulation-based framework to model and evaluate the potential efficiency of many different CCM policies in a controlled and realistic, but VM-independent environment. We make the encouraging discovery that effective CCM policies can sustain high program performance even for very small cache sizes. Our simulation study provides the rationale and motivation to improve CCM strategies in existing VMs. We implement and study the properties of several CCM policies in HotSpot. We find that in spite of working within the bounds of the HotSpot VM’s current CCM sub-system, our best CCM policy implementation in HotSpot improves program performance over the default CCM algorithm by 39%, 41%, 55%, and 50% with code cache sizes that are 90%, 75%, 50%, and 25% of the desired cache size, on average.

Empirical Analysis of HPC Using Different Programming Models

During the last decade, Heterogeneous systems are emerging for high performance computing [1]. In order to achieve high performance computing (HPC), existing technologies and programming models aims to see rapid growth toward intra-node parallelism [2]. The current high computational system and applications demand for a massive level of computation power. In last few years, Graphical processing unit (GPU) has been introduced an alternative of conventional CPU for highly parallel computing applications both for general purpose and graphic processing. Rather than using the traditional way of coding algorithms in serial by single CPU, many multithreading programming models has been introduced such as CUDA, OpenMP, and MPI to make parallel processing by using multicores. These parallel programming models are supportive to data driven multithreading (DDM) principle [3]. In this paper, we have presented performance based preliminary evaluation of these programming models and compared with the conventional single CPU serial processing system. We have implemented a massive computational operation for performance evaluation such as complex matrix multiplication operation. We used data driven multithreaded HPC system for performance evaluation and presented the results with a comprehensive analysis of these parallel programming models for HPC parallelism.

Online Body Schema Adaptation Based on Internal Mental Simulation and Multisensory Feedback

In this paper, we describe a novel approach to obtain automatic adaptation of the robot body schema and to improve the robot perceptual and motor skills based on this body knowledge. Predictions obtained through a mental simulation of the body are combined with the real sensory feedback to achieve two objectives simultaneously: body schema adaptation and markerless 6D hand pose estimation. The body schema consists of a computer graphics simulation of the robot, which includes the arm and head kinematics (adapted online during the movements) and an appearance model of the hand shape and texture. The mental simulation process generates predictions on how the hand will appear in the robot camera images, based on the body schema and the proprioceptive information (i.e. motor encoders). These predictions are compared to the actual images using Sequential Monte Carlo techniques to feed a particle-based Bayesian estimation method to estimate the parameters of the body schema. The updated body schema will improve the estimates of the 6D hand pose, which is then used in a closed-loop control scheme (i.e. visual servoing), enabling precise reaching. We report experiments with the iCub humanoid robot that support the validity of our approach. A number of simulations with precise ground-truth were performed to evaluate the estimation capabilities of the proposed framework. Then, we show how the use of high-performance GPU programming and an edge-based algorithm for visual perception allow for real-time implementation in real world scenarios.

High-performance programming frameworks for numerical simulation

Over the past 20 years, a variety of research activities on high-performance programming have taken place worldwide. General-purpose application programming interfaces (GAPIs) have been designed and standardized; for example, MPI and OpenMP are two successfulGAPIs in the field of numerical simulation. However, with the increase in performance of computer systems from teraflops to petaflops [1], these GAPIs will not be adequate to deal with emerging systems in the next 5–10 years. There are two main reasons for this [2]. First, GAPIs need to be significantly improved or redesigned to deal with the multilevel heterogeneous parallelism or deep memory hierarchies mandated by the power and microarchitecture considerations. Second, domain-specific abstractions for application programming interfaces (DAPIs) are essential to shield application developers from the complexity and availability of such GAPIs. To date, high-performance programming frameworks (HPPFs) have successfully been used in implementing DAPIs in the field of numerical simulation [2]. These frameworks can bridge the gap between application developers and GAPIs with the paradigm of ‘think in parallel and write sequentially’. Physics and numerical algorithms can be programmed sequentially based on a flowchart of the parallel code without any knowledge of GAPIs. Moreover, HPPFs allow parallel code to be ported from petaflop systems to emerging or exascale systems without having to be rewritten. In other words, HPPFs safeguard application software from changes due to evolving computer systems. Typically, HPPFs are in greater demand in institutes where there are more application domain programmers than high-performance programmers. Figure 1 depicts the inner workings of a HPPF. First, domain-specific data structures must be presented for the distribution of computation load toward potentially minimal data movement across thememory hierarchy for efficient implementation of numerical algorithms.Next, the domain-specific data dependencies of the numerical algorithms must be accurately described for the new data structures. Third, parallel computation models (PCMs) can be defined to depict different types of numerical computation phases. Here, each phase represents a type of data dependency among a set of sequential numerical computation entities. Fourth, parallel algorithms for data communication and load balancing must be designed for efficient implementation of the PCMs. Finally, DAPIs are defined as software components [3] using C++ constructs in which data structures are available and numerical computation entities are integrated. Then, the numerical algorithms can be implemented sequentially provided that they can be written as a flowchart comprising numerical computation phases for each existing type of PCM. Further, numerical algorithms can be classified into two types, namely, application aware and independent. The