Identify Performance Bottlenecks Research Articles

H5bench: A unified benchmark suite for evaluating HDF5 I/O performance on pre‐exascale platforms

SummaryParallel I/O is a critical technique for moving data between compute and storage subsystems of supercomputers. With massive amounts of data produced or consumed by compute nodes, high‐performant parallel I/O is essential. I/O benchmarks play an important role in this process; however, there is a scarcity of I/O benchmarks representative of current workloads on HPC systems. Toward creating representative I/O kernels from real‐world applications, we have created h5bench , a set of I/O kernels that exercise hierarchical data format version 5 (HDF5) I/O on parallel file systems in numerous dimensions. Our focus on HDF5 is due to the parallel I/O library's heavy usage in various scientific applications running on supercomputing systems. The various tests benchmarked in the h5bench suite include I/O operations (read and write), data locality (arrays of basic data types and arrays of structures), array dimensionality (one‐dimensional arrays, two‐dimensional meshes, three‐dimensional cubes), I/O modes (synchronous and asynchronous). In this paper, we present the observed performance of h5bench executed along several of these dimensions on existing supercomputers (Cori and Summit) and pre‐exascale platforms (Perlmutter, Theta, and Polaris). h5bench measurements can be used to identify performance bottlenecks and their root causes and evaluate I/O optimizations. As the I/O patterns of h5bench are diverse and capture the I/O behaviors of various HPC applications, this study will be helpful to the broader supercomputing and I/O community.

OPTIMIZING NODE.JS APPLICATION PERFORMANCE THROUGH MAIN THREAD OFFLOADING

Node.js is a JavaScript runtime environment that allows you to run JavaScript code outside of a web browser. It works by using a single thread to handle multiple requests using a callback-based event loop. This means that Node.js operates in an event-driven, non-blocking I/O model. One potential weak point of Node.js is that it is designed to be a single-threaded runtime environment, which means that it may not be the best choice for applications that require a high degree of parallelism or multi-threading. While Node.js can handle multiple I/O operations simultaneously through its event-driven architecture, it can struggle with CPU-bound tasks that require heavy computation. This academic article investigates the concept of "offloading" the main thread in Node.js, which refers to the process of delegating heavy computational tasks to worker threads to improve the overall performance and responsiveness Node. js application. The article provides a comprehensive analysis of different techniques for offloading the main thread, such as using worker threads, child processes, and cluster modules. It also explores the potential trade-offs and performance implications of each technique, and provides recommendations for selecting the most suitable approach for different use cases. The article highlights the importance of optimizing the use of CPU resources and avoiding blocking the event loop, which can lead to degraded performance and poor user experience. It also emphasizes the need for careful monitoring and profiling of Node.js applications to identify performance bottlenecks and optimize the use of available resources. Overall, this article provides valuable insights and practical recommendations for developers and system architects who want to improve the performance and scalability of their Node.js applications by unloading the main thread.

Methodological Framework for Sustainable Transport Corridor Modeling Using Petri Nets

Current models for evaluating sustainable transport corridors often lack a comprehensive framework capturing the multifaceted performance measures vital for holistic assessment especially at the early stages of operation, when detailed information on the performance indicators of these transport corridors is not available. This gap motivates a Petri net-based modeling approach that integrates key sustainability indicators into a flexible simulation tool. This paper details a versatile methodology harnessing Petri nets, specifically Evaluation Petri nets (E-Nets), to assess corridor sustainability across environmental, social, and economic dimensions. The proposed framework equips planners and policymakers to explore diverse green corridor configurations under varying conditions. Case studies showcase the model’s capabilities in analyzing real-world corridors, identifying performance bottlenecks, and comparing alternative solutions. The model provides a practical decision-support tool to strengthen strategies for efficient, socially responsible, and environmentally sound transport infrastructure. This research advances the theoretical foundations and demonstrates the practical value of Petri nets as an enabling methodology for modeling the intricate dynamics of sustainable transport corridors. This paper demonstrates how E-Nets provide a visual and quantitative representation of transport operations, enabling stakeholders to identify inefficiencies and potential improvements. This paper discusses the theoretical underpinnings of the E-Net modeling of transport corridors, the advantages and limitations of its application, and suggests avenues for future research to enhance the model’s predictive power and real-world application. The paper concludes that the E-Net approach is a scalable, adaptable tool that can significantly con-tribute to the sustainable development of international transport corridors, providing a framework for continuous improvement in alignment with global sustainability objectives.

CH-Bench: a user-oriented benchmark for systems for efficient distant reading (design, performance, and insights)

Data science deals with the discovery of information from large volumes of data. The data studied by scientists in the humanities include large textual corpora. An important objective is to study the ideas and expectations of a society regarding specific concepts, like “freedom” or “democracy,” both for today’s society and even more for societies of the past. Studying the meaning of words using large corpora requires efficient systems for text analysis, so-called distant reading systems. Making such systems efficient calls for a specification of the necessary functionality and clear expectations regarding typical work loads. But this currently is unclear, and there is no benchmark to evaluate distant reading systems. In this article, we propose such a benchmark, with the following innovations: As a first step, we collect and structure various information needs of the target users. We then formalize the notion of word context to facilitate the analysis of specific concepts. Using this notion, we formulate queries in line with the information needs of users. Finally, based on this, we propose concrete benchmark queries. To demonstrate the benefit of our benchmark, we conduct an evaluation, with two objectives. First, we aim at insights regarding the content of different corpora, i.e., whether and how their size and nature (e.g., popular and broad literature or specific expert literature) affect results. Second, we benchmark different data management technologies. This has allowed us to identify performance bottlenecks.

Research on the performance optimization issue in the Java programming language

The Java programming language, renowned and widely used, provides developers with a powerful platform for creating programs that can scale and respond quickly to user demands. However, to fully harness Java’s potential, it is necessary to delve deeper into optimization possibilities. This article explores the principles, techniques, and best practices that assist Java developers in crafting programs distinguished by speed, efficiency, and responsiveness. Additionally, it examines tools and strategies that aid in identifying problem areas, fine-tuning code, and enhancing the overall performance of Java applications. A fundamental starting point in optimizing Java applications is profiling and analysis. Profiling tools like VisualVM, YourKit, or built-in options like jVisualVM are indispensable for identifying performance bottlenecks. By uncovering areas in need of improvement, these tools facilitate the fine-tuning of applications Efficient memory management plays a critical role in Java optimization. Proper utilization of Java’s Garbage Collection mechanisms is essential. Different GC algorithms should be explored, and heap sizes tailored to the specific needs of the application. This ensures that memory is allocated and deallocated efficiently, minimizing the risk of memory leaks. Java’s support for multithreading is a powerful resource for enhancing performance. In conclusion, Java is a powerful programming language, and optimizing Java applications is a continuous process. By following these principles, techniques, and best practices, developers can create high-performance applications that respond quickly to user demands. Regular profiling, analysis, and testing are essential to maintaining and improving the efficiency and responsiveness of Java applications. Remember that performance optimization is an ongoing journey, not a one-time task.

Addressing Performance and Scalability Issues in Large-Scale Jenkins Deployments

Jenkins, an open-source automation server, has become a cornerstone in modern software development pipelines, facilitating continuous integration and delivery (CI/CD) processes. However, as the scale of Jenkins deployments increases, organizations encounter significant challenges related to performance and scalability. This review paper delves into the various strategies and approaches aimed at mitigating these challenges in large-scale Jenkins deployments. The paper begins by identifying the key performance bottlenecks and scalability limitations inherent in Jenkins at scale. It explores the impact of factors such as increased workload, extensive plugin usage, and complex pipeline configurations on Jenkins’ performance. Subsequently, the review examines existing research and industry practices in addressing these issues. Several techniques have been proposed and implemented to enhance the performance and scalability of Jenkins deployments. These include optimizing resource utilization through efficient job scheduling algorithms, leveraging distributed architectures to distribute workloads across multiple nodes, and employing caching mechanisms to reduce build times and alleviate strain on Jenkins masters. Furthermore, the paper discusses the role of infrastructureas-code (IaC) practices and containerization technologies in streamlining Jenkins deployments and improving scalability. Moreover, the paper highlights the importance of monitoring and instrumentation in identifying performance bottlenecks and optimizing Jenkins deployments continuously. It discusses various monitoring tools and techniques for gathering performance metrics and diagnosing issues in large-scale Jenkins environments. Overall, this paper provides valuable insights into the challenges faced by organizations deploying Jenkins at scale and offers a comprehensive overview of strategies and best practices for addressing performance and scalability issues. By adopting these approaches, organizations can ensure the efficient operation of their Jenkins infrastructure, enabling smoother CI/CD workflows and enhancing overall software delivery capabilities.

Multistep schemes for solving backward stochastic differential equations on GPU

The Backward Stochastic Differential Equation (BSDE) is an important tool for pricing and hedging. Highly accurate pricing for low computation time becomes interesting for minimizing monetary loss. Therefore, we explore the opportunity of parallelizing high-order multistep schemes in option pricing. In the multistep scheme the computations at each space grid point are independent and this fact motivates us to select massively parallel GPU computing using CUDA. In our investigations we identify performance bottlenecks and apply appropriate optimization techniques to reduce the computation time in a uniform space domain. Runtime experiments manifest optimistic speedups for the parallel implementation on a single GPU, NVIDIA GeForce 1070 Ti.

Technical and technological constraints facing Tanzania leather value chain: a snapshot of intervention measures

The leather value chain starts with livestock, the key source of hides and skins, and the main raw materials for the industry. Despite having the second-largest livestock population in Africa, Tanzania is only the 11th largest exporter of leather on the continent, underlining the disproportionate contribution of the sector to the economy. This study presents the results of a recent assessment aimed at identifying performance bottlenecks in Tanzania's leather sector. The assessment took place in October–December 2020 and involved 10 tanneries, 30 leather goods factories and 11 service providers/institutions. Findings reveal that 90% of tanneries are dissatisfied with the quality of hides and skins due to brand marks, flay cuts, skin diseases, and inadequate curing. These supply chain bottlenecks are further compounded by skill deficiencies among processors, poor waste management, and limited awareness about laws, policies and regulations governing trade in the sector. At the downstream end of the value chain, the trade in leather and related articles is facing competition from high importation of low-grade products like plastic shoes and second-hand products. This paper recommends that efforts to increase leather's economic and trade value need to focus on upgrading Tanzania’s production, processing, branding and marketing capacities.Graphical

Instruction Roofline: An insightful visual performance model for GPUs

AbstractThe Roofline performance model provides an intuitive approach to identify performance bottlenecks and guide performance optimization. However, the classic FLOP‐centric approach is inappropriate for the emerging applications that perform more integer operations than floating point operations. In this article, we reintroduce our Instruction Roofline Model on NVIDIA GPUs and expand our evaluation of it. The Instruction Roofline incorporates instructions and memory transactions across all memory hierarchies together, and provides more performance insights than the FLOP‐oriented Roofline Model, that is, instruction throughput, stride memory access patterns, bank conflicts, and thread predication. We use our Instruction Roofline methodology to analyze eight proxy applications: HPGMG from AMReX, Matrix Transpose benchmarks, ADEPT from MetaHipMer's sequence alignment phase, EXTENSION from MetaHipMer's local assembly phase, CUSP, cuSPARSE, cudaTensorCoreGemm, and cuBLAS. We demonstrate the ability of our methodology to understand various aspects of performance and performance bottlenecks on NVIDIA GPUs and motivate code optimizations.

Daisen: A Framework for Visualizing Detailed GPU Execution

AbstractGraphics Processing Units (GPUs) have been widely used to accelerate artificial intelligence, physics simulation, medical imaging, and information visualization applications. To improve GPU performance, GPU hardware designers need to identify performance issues by inspecting a huge amount of simulator‐generated traces. Visualizing the execution traces can reduce the cognitive burden of users and facilitate making sense of behaviors of GPU hardware components. In this paper, we first formalize the process of GPU performance analysis and characterize the design requirements of visualizing execution traces based on a survey study and interviews with GPU hardware designers. We contribute data and task abstraction for GPU performance analysis. Based on our task analysis, we propose Daisen, a framework that supports data collection from GPU simulators and provides visualization of the simulator‐generated GPU execution traces. Daisen features a data abstraction and trace format that can record simulator‐generated GPU execution traces. Daisen also includes a web‐based visualization tool that helps GPU hardware designers examine GPU execution traces, identify performance bottlenecks, and verify performance improvement. Our qualitative evaluation with GPU hardware designers demonstrates that the design of Daisen reflects the typical workflow of GPU hardware designers. Using Daisen, participants were able to effectively identify potential performance bottlenecks and opportunities for performance improvement. The open‐sourced implementation of Daisen can be found at gitlab.com/akita/vis. Supplemental materials including a demo video, survey questions, evaluation study guide, and post‐study evaluation survey are available at osf.io/j5ghq.

Performance evaluation of a solution for composite service selection problem with multiple consumers

In recent years, building business applications from independently developed services has become one of the current trends in service computing. To satisfy clients’ requirements, service composition is performed to compose the various capabilities of available services. With the proliferation of services having similar functionalities, assessing the quality of a given composition is a paramount factor to decide which services must be selected, or to choose whether a given composition can provide the requested QoS (Quality of Service). However, due to the fluctuating conditions in the dynamic cloud computing environment, the QoS and the performances of the services become unreliable, and therefore call into the question the accuracy of the composition QoS. To tackle this issue, different methods that analyse the QoS have been developed, making it possible to help the designers to first, understand the system behaviour when providers and consumers, are interacting, thus allowing to optimize the system by identifying performance bottlenecks within a specified deployment environment.In this study, the particular problem of many consumers that are competing to acquire services with same functionalities but with different QoS, is considered. For this purpose, assuming a dynamic environment, different models based on Discrete Time Markov Chain are developed to implement several policies of the system. A theoretical modelling of the problem is proposed including analytical results obtained using the Xborne tool. For each model, the average time to reach a given QoS for a community of consumers is reported. Such a performance metric allows the designer to predict the system behaviour in a dynamic environment.

Visualizing Hierarchical Performance Profiles of Parallel Codes Using CallFlow.

Calling context trees (CCTs) couple performance metrics with call paths, helping understand the execution and performance of parallel programs. To identify performance bottlenecks, programmers and performance analysts visually explore CCTs to form and validate hypotheses regarding degraded performance. However, due to the complexity of parallel programs, existing visual representations do not scale to applications running on a large number of processors. We present CallFlow, an interactive visual analysis tool that provides a high-level overview of CCTs together with semantic refinement operations to progressively explore CCTs. Using a flow-based metaphor, we visualize a CCT by treating execution time as a resource spent during the call chain, and demonstrate the effectiveness of our design with case studies on large-scale, production simulation codes.

Hierarchical Roofline analysis for GPUs: Accelerating performance optimization for the NERSC‐9 Perlmutter system

SummaryThe Roofline performance model provides an intuitive and insightful approach to identifying performance bottlenecks and guiding performance optimization. In preparation for the next‐generation supercomputer Perlmutter at NERSC, this paper presents a methodology to construct a hierarchical Roofline on NVIDIA GPUs and extends it to support reduced precision and Tensor Cores. The hierarchical Roofline incorporates L1, L2, device memory, and system memory bandwidths into one single figure, and it offers more profound insights into performance analysis than the traditional DRAM‐only Roofline. We use our Roofline methodology to analyze three proxy applications: GPP from BerkeleyGW, HPGMG from AMReX, and conv2d from TensorFlow. In doing so, we demonstrate the ability of our methodology to readily understand various aspects of performance and performance bottlenecks on NVIDIA GPUs and motivate code optimizations.

Modeling Electrolyte Composition Effects on Anion-Exchange-Membrane Water Electrolyzer Performance

Anion-exchange membrane (AEM) electrolyzers are an attractive alternative for hydrogen production due to the potential stability and activity of non-precious metal catalysts in alkaline environments. Recently, AEM electrolyzers have been demonstrated using various membranes, ionomers, porous-transport layers, and catalysts (1). The influence of these materials and their properties on AEM electrolyzer performance, however, is underdeveloped. Furthermore, recent studies have shown (2) and hydrogen-evolution reaction kinetics (3), offering additional routes to decreasing cost and reducing operating voltage. In this work, we use a coupled, nonisothermal, multiphase model of an AEM electrolyzer to understand the role of material properties, transport phenomena, and reaction kinetics in improving device pformance. We use the model to identify performance bottlenecks through applied voltage breakdowns (AVBs) and provide guidance for next-generation electrolyzer materials and designs by evaluating sensitivity to membrane and catalyst-layer properties. Finally, we explore the effects of various electrolyte solution feeds and operating paradigms on cell performance, with a particular interest in the influence of ion transport on reaction kinetics. Acknowledgements This work was funded under the HydroGEN Consortium, by the Office of Energy Efficiency and Renewable Energy (EERE), of the U.S. Department of Energy under contract number DE-AC02-05CH11231. This work was supported in part by the U.S. Department of Energy, Office of Science, Office of Workforce Development for Teachers and Scientists (WDTS) under the Science Undergraduate Laboratory Internship (SULI) program. This work was also supported in part by Workforce Development & Education at Berkeley Lab. We thank Sanjeev Mukerjee, Ian Kendrick, Yu Seung Kim, and Dongguo Li for helpful discussions. References I. Vincent and D. Bessarabov, Renewable and Sustainable Energy Reviews, 81, 1690 (2018).H. Ito, N. Kawaguchi, S. Someya, T. Munakata, N. Miyazaki, M. Ishida and A. Nakano, International Journal of Hydrogen Energy, 43, 17030 (2018).Q. Jia, E. Liu, L. Jiao, J. Li and S. Mukerjee, Current Opinion in Electrochemistry, 12, 209 (2018).

Guest Editorial: Special Section on “Blockchain for Industrial Internet of Things” in IEEE Transactions on Industrial Informatics

The papers in this special section focus on blockchain for the Industrial Internet of Things (IoT). Industrial IoT is reshaping various industrial sectors, such as manufacturing, logistics, transportation, healthcare, energy, and utilities. IIoT consists of various smart objects distributed throughout the whole industrial system to collect massive ambient data, which can be used to identify performance bottlenecks, troubleshoot faults, and detect malicious behaviors consequently enforcing effective control to the physical world. However, there are several challenges posed on IIoT before the formal adoption of IIoT across various industrial sectors. Among them, security and privacy preservation on IIoT data are the most crucial concerns. On the other hand, the blockchain technology is transforming industries by enabling anonymous and trustful transactions in decentralized and trustless environment. As a result, blockchains help to reduce system risks, mitigate financial fraud, and cut down operational cost. The convergence of IIoT and blockchains can potentially overcome the deficiencies of IIoT consequently resulting in the realization of IIoT in various industrial sectors. Both industry practitioners and academic researchers aim at realizing general, scalable and deployable blockchain-based IIoT platforms in various application domains while there are a number of challenges such as distributed consensus algorithms and data analytics with privacy-preservation in IIoT systems.

Identifying Dominant Recombination Mechanisms in Perovskite Solar Cells by Measuring the Transient Ideality Factor

The ideality factor determined by measuring the open circuit voltage (VOC) as function of light intensity is often used as a means to identify the dominant recombination mechanism in solar cells. However, applying this Suns-VOC technique to perovskite cells is problematic since the VOC evolves with time in a way which depends on the previously applied bias (Vpre), the light intensity, and the device architecture/processing. Here we show that the dominant recombination mechanism in two structurally similar CH3NH3PbI3 devices containing either mesoporous Al2O3 or TiO2 layers can be identified from the signature of the transient ideality factor following application of a forward bias, Vpre, to the device in the dark. The transient ideality factor, is measured by monitoring the temporal evolution of VOC at different light intensities. The initial values of the transient ideality were consistent with corresponding photoluminescence vs intensity as well as electroluminescence vs current density measurements. Time-dependent simulations of the measurement on modelled devices, which include the effects of mobile ionic charge, show that Shockley Read Hall (SRH) recombination through deep traps at the charge collection interfaces is dominant in both devices. Using transient photovoltage measurements superimposed on the evolving VOC of bifacial devices we further show that the charge collection interface extends throughout the mesoporous TiO2 layer, consistent with a transient ideality signature corresponding to SRH recombination in the bulk of the film. This information could not be inferred from an ideality factor determined from only steady-state VOC values. The method we have developed will be useful for identifying performance bottlenecks in new variants of perovskite devices by comparison with the transient ideality signatures we have predicted for a range of possible recombination schemes.

Exploiting Hardware Multicast and GPUDirect RDMA for Efficient Broadcast

Broadcast is a widely used operation in many streaming and deep learning applications to disseminate large amounts of data on emerging heterogeneous High-Performance Computing (HPC) systems. However, traditional broadcast schemes do not fully utilize hardware features for Graphics Processing Unit (GPU)-based applications. In this paper, a model-oriented analysis is presented to identify performance bottlenecks of existing broadcast schemes on GPU clusters. Next, streaming-based broadcast schemes are proposed to exploit InfiniBand hardware multicast (IB-MCAST) and NVIDIA GPUDirect technology for efficient message transmission. The proposed designs are evaluated in the context of using Message Passing Interface (MPI) based benchmarks and applications. The experimental results indicate improved scalability and up to 82 percent reduction of latency compared to the state-of-the-art solutions in the benchmark-level evaluation. Furthermore, compared to the state-of-the-art, the proposed design yields stable higher throughput for a synthetic streaming workload, and 1.3x faster training time for a deep learning framework.

Tuning the Performance of a Computational Persistent Homology Package.

In recent years, persistent homology has become an attractive method for data analysis. It captures topological features, such as connected components, holes, and voids from point cloud data and summarizes the way in which these features appear and disappear in a filtration sequence. In this project, we focus on improving the performance of Eirene, a computational package for persistent homology. Eirene is a 5000-line open-source software library implemented in the dynamic programming language Julia. We use the Julia profiling tools to identify performance bottlenecks and develop novel methods to manage them, including the parallelization of some time-consuming functions on multicore/manycore hardware. Empirical results show that performance can be greatly improved.

Hierarchical Binary CNNs for Landmark Localization with Limited Resources

Our goal is to design architectures that retain the groundbreaking performance of Convolutional Neural Networks (CNNs) for landmark localization and at the same time are lightweight, compact and suitable for applications with limited computational resources. To this end, we make the following contributions: (a) we are the first to study the effect of neural network binarization on localization tasks, namely human pose estimation and face alignment. We exhaustively evaluate various design choices, identify performance bottlenecks, and more importantly propose multiple orthogonal ways to boost performance. (b) Based on our analysis, we propose a novel hierarchical, parallel and multi-scale residual architecture that yields large performance improvement over the standard bottleneck block while having the same number of parameters, thus bridging the gap between the original network and its binarized counterpart. (c) We perform a large number of ablation studies that shed light on the properties and the performance of the proposed block. (d) We present results for experiments on the most challenging datasets for human pose estimation and face alignment, reporting in many cases state-of-the-art performance. (e) We further provide additional results for the problem of facial part segmentation. Code can be downloaded from https://www.adrianbulat.com/binary-cnn-landmarks.

NoDB

As data collections become larger and larger, users are faced with increasing bottlenecks in their data analysis. More data means more time to prepare and to load the data into the database before executing the desired queries. Many applications already avoid using database systems, for example, scientific data analysis and social networks, due to the complexity and the increased data-to-query time, that is, the time between getting the data and retrieving its first useful results. For many applications data collections keep growing fast, even on a daily basis, and this data deluge will only increase in the future, where it is expected to have much more data than what we can move or store, let alone analyze. We here present the design and roadmap of a new paradigm in database systems, called NoDB, which do not require data loading while still maintaining the whole feature set of a modern database system. In particular, we show how to make raw data files a first-class citizen, fully integrated with the query engine. Through our design and lessons learned by implementing the NoDB philosophy over a modern Database Management Systems (DBMS), we discuss the fundamental limitations as well as the strong opportunities that such a research path brings. We identify performance bottlenecks specific for in situ processing, namely the repeated parsing and tokenizing overhead and the expensive data type conversion. To address these problems, we introduce an adaptive indexing mechanism that maintains positional information to provide efficient access to raw data files, together with a flexible caching structure. We conclude that NoDB systems are feasible to design and implement over modern DBMS, bringing an unprecedented positive effect in usability and performance.<!-- END_PAGE_1 -->