Search

Deep learning (DL) has significantly advanced artificial intelligence (AI); however, frameworks such as PyTorch, ONNX, and TensorFlow are optimized for general‐purpose GPUs, leading to inefficiencies on specialized accelerators such as neural processing units (NPUs) and processing‐in‐memory (PIM) devices. These accelerators are designed to optimize both throughput and energy efficiency but they require more tailored optimizations. To address these limitations, we propose the NEST compiler (NEST‐C), a novel DL framework that improves the deployment and performance of models across various AI accelerators. NEST‐C leverages profiling‐based quantization, dynamic graph partitioning, and multi‐level intermediate representation (IR) integration for efficient execution on diverse hardware platforms. Our results show that NEST‐C significantly enhances computational efficiency and adaptability across various AI accelerators, achieving higher throughput, lower latency, improved resource utilization, and greater model portability. These benefits contribute to more efficient DL model deployment in modern AI applications. [ABSTRACT FROM AUTHOR]

Summary: Containers have taken over large swaths of cloud computing as the most convenient way of packaging and deploying applications. The features that containers offer for packaging and deploying applications translate to high performance computing (HPC) as well. At The National Oceanic and Atmospheric Administration, containers provide an easy way to build and distribute complex HPC applications, allowing faster collaboration, portability, and experiment computer environment reproducibility amongst the scientific community. The challenge arises when applications rely on message passing interface (MPI). This necessitates investigation into how to properly run these applications with their own unique requirements and produce performance on par with native runs. We investigate the MPI performance for benchmarks and containerized climate models for various containers covering selection of compiler and MPI library combinations from the Cray provided programming environments on the Cray XC supercomputer GAEA. Performance from the benchmarks and the climate models shows that for the most part containerized applications perform on par with the natively built applications when the system optimized Cray MPICH libraries are bound into the container, and the hybrid model containers have poor performance in comparison. We also describe several challenges and our solutions in running these containers, particularly challenges with heterogeneous jobs for the containerized model runs. [ABSTRACT FROM AUTHOR]

The Java virtual machine (JVM) is the cornerstone of the Java platforms. A JVM's exception handling implementation interrupts, when the objective application encounters an exception (or an error), the normal execution of the application and performs specific handling tasks. However, little research has been done in systematically validating JVMs' exception handling implementations—test programs or even applications need to be carefully designed for throwing/catching exceptions at runtime; a JVM's exception handling implementation is also complicated, making it challenging to design tests for testing all of its functionalities. Inspired by the recent success of fuzz testing of compilers and JVM implementations, we introduce EHCBuilder, the first technique for fuzzing JVMs' exception handling implementations. The key idea is to construct exception handling chains, each of which abstracts a program's execution into a sequence of exception throwings, catchings, and/or handlings. A classfile seed can then be mutated into test programs with diverse exception handling chains, enabling (1) exceptions to be continuously thrown and caught at runtime, and (2) JVMs' exception handling implementations to be much more thoroughly tested. We have implemented EHCBuilder and evaluated EHCBuilder on popular JVM implementations including OpenJDK's HotSpot, Eclipse's OpenJ9, Azul's Zulu, and Oracle's GraalVM. Our results show that EHCBuilder can generate programs with very intricate exception handling chains and reveal differences among JVMs' exception handling implementations: Up to thousands of lines of source code in HotSpot's exception handling implementation are covered more than the original benchmarks; during 39 K iterations, EHCBuilder generates exception handling chains of different lengths, revealing 258 runtime differences. We classify the differences into four categories, and reveal a fast throw issue confirmed by HotSpot developers and another initCause issue confirmed by the OpenJ9 community. [ABSTRACT FROM AUTHOR]

Summary: This paper presents an extended version of our previous work on using compiler technology to automatically convert sequential C++ data abstractions, for example, queues, stacks, maps, and trees, to concurrent lock‐free implementations. A key difference between our work and existing research in software transactional memory (STM) is that our compiler‐based approach automatically selects the best state‐of‐the‐practice nonblocking synchronization method for the underlying sequential implementation of the data structure. The extended material includes a broader collection of the state‐of‐the‐practice lock‐free synchronization techniques, additional formal correctness proofs of the overall integration of the different synchronizations in our system, and a more comprehensive experimental study of the integrated techniques. We evaluate our compiler‐generated nonblocking data structures both by using a collection of micro‐benchmarks, including the Synchrobench suite, and by using a multi‐threaded application Dedup from PARSEC. Our automatically synchronized code attains performance competitive to that of concurrent data structures manually‐written by experts and much better performance than heavier‐weight support by STM. [ABSTRACT FROM AUTHOR]

Developing a just‐in‐time (JIT) compiler can be a daunting task, especially for a language as flexible as Python. While PyPy, powered with JIT compilation, can often outperform the official pure interpreter, CPython, by a noteworthy margin, its popularity remains far from comparable to that of CPython due to some issues. Given that an easier‐to‐deploy and better‐compatible JIT compiler would benefit more Python users, we have developed comPyler, a simple JIT compiler functioning as a CPython extension and intended to convert frequently interpreted CPython bytecode into equivalent machine code. Designed with good compatibility in mind, it does not alter CPython's internal data structures or external interfaces. Based on LLVM's mature infrastructure, it can be readily ported to almost all platforms. Compared with CPython, it achieved the highest speedup of 2.205, with an average of 1.093. Despite its relatively limited effect, comPyler incurs low development costs. As a baseline compiler, it also sheds light on the improvement attainable by optimizing solely the overhead of bytecode interpretation. Furthermore, as there is still a dearth of empirical research covering the multitude of JIT compilers available for Python, we have conducted a performance study that examines Jython, IronPython, PyPy, GraalPy, Pyston, Pyjion, and our comPyler. Our research takes into account not only the benchmark speed for various time windows but also the boot latency and memory footprint. Through this comprehensive study, our objective is to assist developers in gaining a better understanding of the effects of distinct JIT compilation techniques and to aid users in making informed decisions when choosing among different Python implementations. [ABSTRACT FROM AUTHOR]

Summary: The wide adoption of SYCL as an open‐standard API for accelerating C++ software in domains such as HPC, automotive, artificial intelligence, machine learning, and other areas necessitates efficient compiler and runtime support for a growing number of different platforms. Existing SYCL implementations provide support for various devices like CPUs, GPUs, DSPs, FPGAs and so forth, typically via OpenCL or CUDA backends. While accelerators have increased the performance of user applications significantly, employing CPU devices for further performance improvement is beneficial due to the significant presence of CPUs in existing data‐centers. SYCL applications on CPUs, currently go through an OpenCL backend. Though an OpenCL backend is valuable in supporting accelerators, it may introduce additional overhead for CPUs since the host and device are the same. Overheads like a run‐time compilation of the kernel, transferring of input/output memory to/from the OpenCL device, invoking the OpenCL kernel and so forth, may not be necessary when running on the CPU. While some of these overheads (such as data transfer) can be avoided by modifying the application, it can introduce disparity in the SYCL application's ability to achieve performance portability on other devices. In this article, we propose an alternate approach to running SYCL applications on CPUs. We bypass OpenCL and use a CPU‐directed compilation flow, along with the integration of whole function vectorization to generate optimized host and device code together in the same translation unit. We compare the performance of our approach—the CPU‐directed compilation flow, with an OpenCL backend for existing SYCL‐based applications, with no code modification for BabelStream benchmark, Matmul from the ComputeCpp SDK, N‐body simulation benchmarks and SYCL‐BLAS (Aliaga et al. Proceedings of the 5th International Workshop on OpenCL; 2017.), on CPUs from different vendors and architectures. We report a performance improvement of up to 72%$$ 72\% $$ on BabelStream benchmarks, up to 63%$$ 63\% $$ on Matmul, up to 21%$$ 21\% $$ on the N‐body simulation benchmark and up to 16% on SYCL‐BLAS. [ABSTRACT FROM AUTHOR]

Summary: While heterogeneous computing has emerged as a dominant trend in current and future High‐Performance Computing (HPC) systems, it is also widely recognized that this shift has led to increased software complexity due to a proliferation of programming systems for different heterogeneous processors. One such example is the Heterogeneous‐Compute Interface for Portability from AMD (HIP), which is composed of a C Runtime API and C++ Kernel Language. Many HPC applications will likely use HIP on future exascale systems (e.g., Frontier and El Capitan), but HIP currently only targets AMD and NVIDIA processors. This limitation creates challenges for users who would also like to run their applications on exascale systems based on other architectures (e.g., Aurora, which is based on Intel hardware) that are currently not targeted by HIP. In this paper, we introduce the design and implementation of HIPLZ , a compiler and runtime system that uses the Intel Level Zero API to support HIP on Intel GPU architectures. We discuss the design of HIPLZ , derived from HIPCL (an implementation of HIP on top of OpenCL), and portability issues that occur from using the Level Zero runtime as a backend. We evaluate our implementation by running several performance benchmarks and mini‐apps written in HIP on Intel architectures using HIPLZ. Our results show that this approach provides competitive performance relative to Intel's OpenCL implementations on Intel Gen9 and UHD Graphics 770 GPUs, while providing good coverage of features needed by HPC applications. Overall, this approach is a promising demonstration of enabling performance portability for exascale systems. [ABSTRACT FROM AUTHOR]

The resurgence of machine learning has increased the demand for high‐performance basic linear algebra subroutines (BLAS), which have long depended on libraries to achieve peak performance on commodity hardware. High‐performance BLAS implementations rely on a layered approach that consists of tiling and packing layers—for data (re)organization—and micro kernels that perform the actual computations. The algorithm for the tiling and packing layers is target independent but is parameterized to the memory hierarchy and register‐file size. The creation of high‐performance micro kernels requires significant development effort to write tailored assembly code for each architecture. This hand optimization task is complicated by the recent introduction of matrix engines by IBM®$$ {\mathrm{IBM}}^{\circledR } $$'s POWER10TM$$ \mathrm{POWER}{10}^{\mathrm{TM}} $$ (Matrix Multiply Assist—MMA), Intel®$$ {\mathrm{Intel}}^{\circledR } $$ (Advanced Matrix eXtensions—AMX), and Arm®$$ {\mathrm{Arm}}^{\circledR } $$ (Matrix Extensions—ME) to deliver high‐performance matrix operations. This article presents a compiler‐only alternative to the use of high‐performance libraries by incorporating, to the best of our knowledge and for the first time, the automatic generation of the layered approach into LLVM, a production compiler. Modular design of the algorithm, such as the use of LLVM's matrix‐multiply intrinsic for a clear interface between the tiling and packing layers and the micro kernel, makes it easy to retarget the code generation to multiple accelerators. The parameterization of the tiling and packing layers is demonstrated in the generation of code for the MMA unit on IBM's POWER10. This article also describes an algorithm that lowers the matrix‐multiply intrinsic to the MMA unit. The use of intrinsics enables a comprehensive performance study. In processors without hardware matrix engines, the tiling and packing delivers performance up to 22×$$ 22\times $$ (Intel)—for small matrices—and more than 6×$$ 6\times $$ (POWER9)—for large matrices—faster than PLuTo, a widely used polyhedral optimizer. The performance also approaches high‐performance libraries and is only 34%$$ 34\% $$ slower than OpenBLAS and on‐par with Eigen for large matrices. With MMA in POWER10 this solution is, for large matrices, over 2.6×$$ 2.6\times $$ faster the vector‐extension solution, matches Eigen performance, and achieves up to 96%$$ 96\% $$ of BLAS peak performance. [ABSTRACT FROM AUTHOR]

Tuning application performance on modern computing infrastructures involves choices in a vast design space as modern computing architectures can have several complex structures impacting performance. Moreover, different applications use these structures in different ways, leading to a challenging performance function. Consequently, it is hard for compilers or experts to find optimal compilation parameters for an application that maximizes such performance function. One approach to tackle this problem is to evaluate many possible optimization plans and select the best among them. However, executing an application to measure its performance for every plan can be very expensive. To tackle this problem, previous work has investigated the use of Machine Learning techniques to predict the performance of the applications without executing them quickly. In this work, we evaluate the use of graph neural networks (GNN) to make fast predictions without executing the application to guide the selection of good optimization sequences. We propose a GNN architecture to make such predictions. We train and test it using 30 thousand different compilation plans applied to 300 different applications, using ARM64 and LLVM IR code representations as input. Our results indicate that the control and data flow graph can then learn features from the control and data flow graph to outperform nongraph‐aware Machine Learning models. Our GNN architecture achieved 91% accuracy in our dataset compared to 79% when using a nongraph‐aware architecture–taking only 16ms to predict a given input. If the application been optimized took an average of 10 s to execute, and we evaluated 1000 optimization sequences, it would take almost 9 h to assess all pairs, but only 16 s with our GNN. [ABSTRACT FROM AUTHOR]

Recently, embedded systems, such as mobile platforms, have multiple processing units that can operate in parallel, such as centralized processing units (CPUs) and neural processing units (NPUs). We can use deep‐learning compilers to generate machine code optimized for these embedded systems from a deep neural network (DNN). However, the deep‐learning compilers proposed so far generate codes that sequentially execute DNN operators on a single processing unit or parallel codes for graphic processing units (GPUs). In this study, we propose PartitionTuner, an operator scheduler for deep‐learning compilers that supports multiple heterogeneous PUs including CPUs and NPUs. PartitionTuner can generate an operator‐scheduling plan that uses all available PUs simultaneously to minimize overall DNN inference time. Operator scheduling is based on the analysis of DNN architecture and the performance profiles of individual and group operators measured on heterogeneous processing units. By the experiments for seven DNNs, PartitionTuner generates scheduling plans that perform 5.03% better than a static type‐based operator‐scheduling technique for SqueezeNet. In addition, PartitionTuner outperforms recent profiling‐based operator‐scheduling techniques for ResNet50, ResNet18, and SqueezeNet by 7.18%, 5.36%, and 2.73%, respectively. [ABSTRACT FROM AUTHOR]

The Ethereum blockchain stores and executes complex logic via smart contracts written in Solidity, a high‐level programming language. The Solidity language (in its early versions) provides features to exercise fine‐grained control over smart contracts, whose usage is discouraged by later‐released Solidity documentation, but nonetheless supported in later versions for backward compatibility. We define these features as low‐level functions. However, the high‐volume of transactions and the improper use of low‐level functions lead to security exploits with heavy financial loss. Consequently, the documentation suggests secure alternatives to the use of low‐level functions. In this article, we first perform an empirical study on the use of low‐level functions in Ethereum smart contracts. We study a smart contract dataset consisting of over 2,100,000 real‐world smart contracts. We find that low‐level functions are widely used and that the majority of these uses are gratuitous. We then propose GoHigh, a source‐to‐source transformation tool to eliminate low‐level function‐related vulnerabilities, by replacing low‐level functions with secure alternatives. Our experimental evaluation on the dataset shows that GoHigh successfully replaces all low‐level functions with 4.9% fewer compiler warnings. Further, no unintended side‐effects are introduced in 80% of the contracts, and the remaining 20% are not verifiable due to their external dependency. GoHigh saves more than 5% of the gas cost of the contract. Finally, GoHigh takes 7 s on average per contract. [ABSTRACT FROM AUTHOR]

Compilation errors are unavoidable during the debugging process of novice students. Compiler error messages can help novices to localize and remove errors, but these messages are difficult to understand for students. Previous studies have investigated the compilation error categorization by analyzing compiler error messages, but the categorization cannot cover all kinds of errors, which limits the evaluation of compilation error studies. Therefore, a comprehensive categorization for compilation errors is needed for evaluating the performance of models or tools related to compilation errors. In this study, we first propose a new compilation error categorization, which is based on the smallest unit of the program, tokens. The experiments on 29,573 programs from three datasets show that our proposed compilation error categorization can cover more types of errors and the distribution of the error categorization are significantly different between the datasets. Then, based on our proposed categorization, we develop a neural network model CLACER (CLAssification of Compilation ERrors) for predicting the compilation errors. The results indicate that CLACER can improve the compiler's error localization accuracy and predicts the compilation error effectively. Moreover, based on the proposed categorization, we conduct empirical studies to evaluate the performance of three repairing tools (i.e., DeepFix, RLAssist, and MACER). The comparison results illustrate that DeepFix and RLAssist can fix more errors in the category of delimiter than errors in other categories. Furthermore, MACER performs better than DeepFix and RLAssist because it has a sufficient repairing pattern set for the errors. We also provide some suggestions for improving the repairing tools in the future. [ABSTRACT FROM AUTHOR]

In an 1854 lecture, TH Huxley suggested that physiology should be measured by its contribution to science, its practical worth and the extent to which it should be made a branch of education. Since macrophysiology, or the investigation of variation in physiological traits over large geographical and temporal scales and the ecological implications of this variation, is well‐established and approaching its third decade, these questions are posed for it here. The field is, of course, much older, but, over the last two decades, has contributed substantially to fundamental eco‐evolutionary research and to understanding the conservation consequences of physiological variation at regional and global scales. Its greatest successes have been in understanding variation in thermal and metabolic responses of animals and plants to variable environments and the significance thereof in the context of the climate crisis. By contrast, much less progress has been made in understanding the regulation of water in the context of currently changing environments and projections of further impacts associated with ongoing global change. The development of new datasets of physiological traits across broad spatial scales has been a slower enterprise than the further compilation of trait databases from extant data. Surprising insights have emerged from genomics‐based microbial macrophysiology, an approach which has much potential to span all of life's variety. The findings of macrophysiological investigations have been taken up within policy reports and/or implementation actions, such as those of the IPCC and the Antarctic Treaty System, that have resulted in benefits to society and to the environment. Yet, as is the case with other areas of research, much remains to be done to develop further strategies to counteract the anti‐science attitudes that are now so prevalent globally. [ABSTRACT FROM AUTHOR]

Increasingly precise spatial data (e.g. high‐resolution imagery from remote sensing) allow for improved representations of the landscape network for assessing the combined effects of habitat loss and connectivity declines on biodiversity. However, evaluating large landscape networks presents a major computational challenge both in terms of working memory and computation time. We present the ConScape (i.e. "connected landscapes") software library implemented in the high‐performance open‐source Julia language to compute metrics for connected habitat and movement flow on high‐resolution landscapes.The combination of Julia's 'just‐in‐time' compiler, efficient algorithms and 'landmarks' to reduce the computational load allows ConScape to compute landscape ecological metrics—originally developed in metapopulation ecology (such as 'metapopulation capacity' and 'probability of connectivity')—for large landscapes. An additional major innovation in ConScape is the adoption of the randomized shortest paths framework to represent connectivity along the continuum from optimal to random movements, instead of only those extremes.We demonstrate ConScape's potential for using large datasets in sustainable land planning by modelling landscape connectivity based on remote‐sensing data paired with GPS tracking of wild reindeer in Norway. To guide users, we discuss other applications, and provide a series of worked examples to showcase all ConScape's functionalities in Supplementary Material.Built by a team of ecologists, network scientists and software developers, ConScape is able to efficiently compute landscape metrics for high‐resolution landscape representations to leverage the availability of large data for sustainable land use and biodiversity conservation. As a Julia implementation, ConScape combines computational efficiency with a transparent code base, which facilitates continued innovation through contributions from the rapidly growing community of landscape and connectivity modellers using Julia. [ABSTRACT FROM AUTHOR]

Motivation: The subdivision of the Earth's terrestrial surface into different biomes, ecozones, bio‐climatic realms or other large ecological land units is an essential reference for global biogeographical and ecological studies. Various classification schemes exist. These differ significantly in terms of the considered criteria for classification and the underlying methodology of class assignments. Evident divergences between global biome concepts are elusive, weakening hereon based analyses and assumptions. Compilation and standardization are essential for obtaining a framework that enables the comparison of different products. To address this need, we created a catalogue of standardized categorial biome maps comprising 31 different global products based on various methodological approaches. These products were processed individually to facilitate their use in large‐scale biogeographical and ecological analyses. Main types of variables contained: We provide a unified RasterStack containing 31 terrestrial biome and land‐cover classifications in different layers. Additional ancillary and processing information is allocated. Spatial location and grain: Global, 10 km × 10 km grain size in equal‐area Mollweide projection. Major taxa and level of measurement: Biomes, ecozones, bio‐climatic zones, and ecological land units. Software format: GeoTiff. [ABSTRACT FROM AUTHOR]

We develop a ytopt autotuning framework that leverages Bayesian optimization to explore the parameter space search and compare four different supervised learning methods within Bayesian optimization and evaluate their effectiveness. We select six of the most complex PolyBench benchmarks and apply the newly developed LLVM Clang/Polly loop optimization pragmas to the benchmarks to optimize them. We then use the autotuning framework to optimize the pragma parameters to improve their performance. The experimental results show that our autotuning approach outperforms the other compiling methods to provide the smallest execution time for the benchmarks syr2k, 3mm, heat‐3d, lu, and covariance with two large datasets in 200 code evaluations for effectively searching the parameter spaces with up to 170,368 different configurations. We find that the Floyd–Warshall benchmark did not benefit from autotuning. To cope with this issue, we provide some compiler option solutions to improve the performance. Then we present loop autotuning without a user's knowledge using a simple mctree autotuning framework to further improve the performance of the Floyd–Warshall benchmark. We also extend the ytopt autotuning framework to tune a deep learning application. [ABSTRACT FROM AUTHOR]

Due to the design of computer systems in the multi‐core and/or multi‐processor form, it is possible to use the maximum capacity of processors to run an application with the least time consumed through parallelisation. This is the responsibility of parallel compilers, which perform parallelisation in several steps by distributing iterations between different processors and executing them simultaneously to achieve lower runtime. The present paper focuses on the uniformisation of three‐level perfect nested loops as an important step in parallelisation and proposes a method called Towards Three‐Level Loop Parallelisation (TLP) that uses a combination of a Frog Leaping Algorithm and Fuzzy to achieve optimal results because in recent years, many algorithms have worked on volumetric data, that is, three‐dimensional spaces. Results of the implementation of the TLP algorithm in comparison with existing methods lead to a wide variety of optimal results at desired times, with minimum cone size resulting from the vectors. Besides, the maximum number of input dependence vectors is decomposed by this algorithm. These results can accelerate the process of generating parallel codes and facilitate their development for High‐Performance Computing purposes. [ABSTRACT FROM AUTHOR]

Since its publication more than 15 years ago the GenX software has been continuously developed and has established itself as a standard package for analyzing X-ray and neutron reflectometry data. The evolution of the software during the last two major revisions is reported here. This includes a simplified model builder for beginners, simple samples, additional sample models, statistical error analysis and the use of just-in-time compilation modules for the reflectometry kernel to achieve higher performance. In addition, the influence of experimental errors on the reflectivity curve is discussed, and new features are described that allow the user to include these in the error statistics to improve the fitting and uncertainty estimation. [ABSTRACT FROM AUTHOR]

To quantitatively convert upper mantle seismic wave speeds measured into temperature, density, composition, and corresponding and uncertainty, we introduce the Whole‐rock Interpretative Seismic Toolbox For Ultramafic Lithologies (WISTFUL). WISTFUL is underpinned by a database of 4,485 ultramafic whole‐rock compositions, their calculated mineral modes, elastic moduli, and seismic wave speeds over a range of pressure (P) and temperature (T) (P = 0.5–6 GPa, T = 200–1,600°C) using the Gibbs free energy minimization routine Perple_X. These data are interpreted with a toolbox of MATLAB® functions, scripts, and three general user interfaces: WISTFUL_relations, which plots relationships between calculated parameters and/or composition; WISTFUL_geotherms, which calculates seismic wave speeds along geotherms; and WISTFUL_inversion, which inverts seismic wave speeds for best‐fit temperature, composition, and density. To evaluate our methodology and quantify the forward calculation error, we estimate two dominant sources of uncertainty: (a) the predicted mineral modes and compositions, and (b) the elastic properties and mixing equations. To constrain the first source of uncertainty, we compiled 122 well‐studied ultramafic xenoliths with known whole‐rock compositions, mineral modes, and estimated P‐T conditions. We compared the observed mineral modes with modes predicted using five different thermodynamic solid solution models. The Holland et al. (2018, https://doi.org/10.1093/petrology/egy048) solution models best reproduce phase assemblages (∼12 vol. % phase root‐mean‐square error [RMSE]) and estimated wave speeds. To assess the second source of uncertainty, we compared wave speed measurements of 40 ultramafic rocks with calculated wave speeds, finding excellent agreement (Vp RMSE = 0.11 km/s). WISTFUL easily analyzes seismic datasets, integrates into modeling, and acts as an educational tool. Key Points: Whole‐rock Interpretative Seismic Toolbox For Ultramafic Lithologies is a software toolbox that interprets mantle seismic wave speed into temperature, density, and composition with uncertaintyThe uncertainty on the forward calculation of seismic wave speed for ultramafic lithologies is 0.5% for Vp and VsThe Holland et al. (2018, https://doi.org/10.1093/petrology/egy048) solution models best reproduce mineral modes for a new compilation of well‐studied ultramafic xenoliths [ABSTRACT FROM AUTHOR]

In the context of programming language courses, offering early and personalized assistance to students with difficulties in solving code exercises is fundamental to helping them improve their performance. To this end, it is desirable to detect those students with behavioral patterns that could potentially result in poor performance in a timely manner. In this study, we analyze different behavioral metrics for predicting the performance of students in a 2nd‐year computer science course. Metrics are extracted from practical sessions, that is, code exercise labs that may be finished online during a period of 5–7 days. In addition to well‐known metrics (e.g., the relative time spent solving compilation/execution errors or skills for removing compilation errors), we also incorporate metrics that take into account the work habits of students (e.g., timestamps in which the student has undertaken 25%, 50%, and 75% of the exercise lab) and similarity between codes. With a sample of 224 students from seven different course groups, we construct robust predictors by training different machine learning models, reaching an R2 value of up to 0.40. We also perform a machine learning‐based analysis for detecting the most relevant response variables and analyze their relations to the final grades of students. The results show that the newly considered metrics have enough predictive power to be considered in the model. Finally, we graphically illustrate the nonlinear and seemingly interdependent relations that exist between predictor and response variables. [ABSTRACT FROM AUTHOR]

The need for assembled existing and new toxicity data has accelerated as the amount of chemicals introduced into commerce continues to grow and regulatory mandates require safety assessments for a greater number of chemicals. To address this evolving need, the ECOTOXicology Knowledgebase (ECOTOX) was developed starting in the 1980s and is currently the world's largest compilation of curated ecotoxicity data, providing support for assessments of chemical safety and ecological research through systematic and transparent literature review procedures. The recently released version of ECOTOX (Ver 5, www.epa.gov/ecotox) provides single‐chemical ecotoxicity data for over 12,000 chemicals and ecological species with over one million test results from over 50,000 references. Presented is an overview of ECOTOX, detailing the literature review and data curation processes within the context of current systematic review practices and discussing how recent updates improve the accessibility and reusability of data to support the assessment, management, and research of environmental chemicals. Relevant and acceptable toxicity results are identified from studies in the scientific literature, with pertinent methodological details and results extracted following well‐established controlled vocabularies and newly extracted toxicity data added quarterly to the public website. Release of ECOTOX, Ver 5, included an entirely redesigned user interface with enhanced data queries and retrieval options, visualizations to aid in data exploration, customizable outputs for export and use in external applications, and interoperability with chemical and toxicity databases and tools. This is a reliable source of curated ecological toxicity data for chemical assessments and research and continues to evolve with accessible and transparent state‐of‐the‐art practices in literature data curation and increased interoperability to other relevant resources. Environ Toxicol Chem 2022;41:1520–1539. © 2022 SETAC. This article has been contributed to by US Government employees and their work is in the public domain in the USA. [ABSTRACT FROM AUTHOR]

Summary: We present a technique and automated toolbox for randomized testing of C compilers. Unlike prior compiler‐testing approaches, we generate concurrent test cases in which threads communicate using fine‐grained atomic operations, and we study actual compiler implementations rather than abstract mappings. Our approach is (1) to generate test cases with precise oracles directly from an axiomatization of the C concurrency model; (2) to apply metamorphic fuzzing to each test case, aiming to amplify the coverage they are likely to achieve on compiler codebases; and (3) to execute each fuzzed test case extensively on a range of real machines. Our tool, C4, benefits compiler developers in two ways. First, test cases generated by C4 can achieve line coverage of parts of the LLVM C compiler that are reached by neither the LLVM test suite nor an existing (sequential) C fuzzer. This information can be used to guide further development of the LLVM test suite and can also shed light on where and how concurrency‐related compiler optimizations are implemented. Second, C4 can be used to gain confidence that a compiler implements concurrency correctly. As evidence of this, we show that C4 achieves high strong mutation coverage with respect to a set of concurrency‐related mutants derived from a recent version of LLVM and that it can find historic concurrency‐related bugs in GCC. As a by‐product of concurrency‐focused testing, C4 also revealed two previously unknown sequential compiler bugs in recent versions of GCC and the IBM XL compiler. [ABSTRACT FROM AUTHOR]

Motivation: Insects provide vital ecological functions and account for over half of all described species. An at least basic understanding of their geographical distributions is key for addressing a range of central ecological and evolutionary questions and to inform conservation. However, even for popular groups, such as butterflies, the knowledge of species' distributions at global scale remains highly incomplete. To address this information gap, we present a data product of comprehensive country‐level occurrences for the 19,327 accepted species of extant butterflies. This compilation is based on a quality‐controlled combination of 165 literature sources and publicly available occurrence records from Global Biodiversity Information Facility (GBIF), harmonized to a global master taxonomy, and constitutes 159,659 (87,506 unique) species–country combinations. We developed a protocol for the integration of country‐level information from literature into the process of cleaning/validating species point occurrence records that facilitates dynamic updates of these country‐level checklist data. Such occurrence records are available for less than 54% of the species, with an apparent bias towards temperate regions and taxa. We use this combined database for a global assessment of the geographical variation in the diversity of butterflies, including an analysis of latitudinal gradients in the species richness—the first undertaken at this higher resolution. Country‐level richness decreases from the equator to the poles, both with and without control for country sizes. The presented data and analyses highlight the potential of leveraging multiple types of distribution information, particularly for taxa with limited data and their incorporation in ecological and conservation analysis. Our database and associated workflows provide a basis for an improved biogeographical understanding and conservation of insect biodiversity. Main types of variables contained: Country‐level occurrences and their sources. Spatial location and grain: Global, 256 countries. Time period and grain: 1861 to 2021. Major taxa and level of measurement: 19,191 accepted species of extant butterflies. Software format:.csv,.shp. [ABSTRACT FROM AUTHOR]

Recently, big data specific technologies have been emerging, including domain‐specific languages, software frameworks, databases, third‐party libraries, and so forth. These techniques are successful in concealing the low‐level details by producing high‐level code, which is passed through the conventional compilation cycle for generating hardware operable code. Several optimization opportunities exist in the compiler which can assist in meeting the processing deadlines of big data workloads, through optimized machine code. However, the existing iterative compilation techniques are not enough for the exploration of big data applications. In this regard, a novel engine has been presented for exploiting the compiler optimization space of big data workloads. The engine is comprised of training and testing phases. During the training stage, the big data application is optimized with Mitigates the Compiler Phase‐ordering (MiCOMP) and genetic algorithm (GA) optimization sequences, which are executed with train datasets. In the testing stage, the test datasets are executed only for the best 300 optimization sequences discovered at the training stage. The proposed engine has been tested with graph mining, machine learning, and text search categories of big data applications using a wide range of real‐world and synthetic datasets. Overall, the engine is 56.8×, 47×, and 9.8× faster than Iterative Optimization for the Data Center (IODC), MiCOMP, and GA respectively in exploiting the compiler search space for big data workloads. Further, the integration of best‐10 and best‐3 techniques with the engine brings a speedup of 5.9× and 7.8×. The compiler level exploitation of general‐purpose machines incurs no extra overhead, no heavy computing, and no personnel cost. Also, the overall performance of big data specialized software solutions can be enhanced by compiling their high‐level code with suitable compiler optimizations. [ABSTRACT FROM AUTHOR]

Summary: Nowadays, people use multiple devices to meet the growing requirement for computing. With the application of multicard computing, fault tolerance, load balance, and resource sharing have been the hot issues and the checkpoint/restart (CPR) mechanism is critical in a preemptive system. This article proposes a CPR framework including the automatic compiler (CRAC) to achieve a feasible CPR system, especially for graphics processing unit applications on heterogeneous devices in OpenCL programs. By offering the positions of the CPR in source code, CRAC inserts primitives into programs and invokes the runtime support modules for final results. A comprehensive example and experiments have demonstrated the feasibility and effectiveness of proposed framework. [ABSTRACT FROM AUTHOR]

High-performance computing (HPC) offers the computing power to continuously support the world's most important discoveries in various scientific and business domains such as chemistry, physics, biology, material science, drug discovery, and financial investment risk analysis. Researchers from across the HPC community have been developing software systems, tools, libraries, frameworks, application packages, and methods that can fully exploit these extremely powerful computing resources. The eleventh paper titled "A large scale parallel fluid-structure interaction computing platform for simulating structural responses to a detonation shock" by Yang et al.[10] presents a partitioned fluid-structure interaction computing platform designed for parallel simulating structural responses to a detonation shock. [Extracted from the article]

Summary: A new efficient implementation of the multithreaded quicksort algorithm called CPP11sort is presented. This implementation is built exclusively upon the threading primitives of the C++ programming language itself. The performance of CPP11sort is evaluated and compared with its mainstream competitors provided by GNU, Intel, and Microsoft. It is shown that out of the considered implementations, CPP11sort mostly yields the shortest sorting times and is the only one that is portable to any conforming C++ implementation without a need of external libraries or nonstandard compiler extensions. The experimental evaluation with various input data distributions resulted in parallel speedup between 16.1 and 44.2 on a 56‐core server and between 6.8 and 14.5 on a 10‐core workstation with enabled hyperthreading. [ABSTRACT FROM AUTHOR]

Convolution is a primary operation in convolution neural networks. The speed of inference is mainly decided by the speed of the convolutional layer. Improving the performance of embedded processors makes it possible to process the inference on embedded devices. In this article, a pipelining strategy of single instruction and multiple data (SIMD) instructions is proposed to finely optimize the process of the 3 × 3 convolution on ARM‐based CPUs. We implement the SIMD group to improve the efficiency of the SIMD pipeline. A tiling method is exploited to increase data reuse during the process. An evaluation model is proposed to guide the design of the tiling method and register allocation. The speed of our implementation is 5.18 times of the GNU compiler collection compiled unoptimized version on RK3288. The effect of our optimizing method is measured by a performance profiling tool, the performance information suggests that the pipelining strategy has a significant effect for both normal and depthwise separable convolution. By implementing multithread processing, the speedup achieves 18.3 compared with the single thread unoptimized version. [ABSTRACT FROM AUTHOR]

Simulation‐based learning tools have become commonly used at all levels of education. They are recognized as an effective means of studying complex and abstract systems. In traditional teaching of compiler concepts, students are incapable of visualizing theoretical constructions, while the use of simulation systems represents an excellent blend of theoretical and practical experience. This paper describes a software system for visualization and simulation of basic compiler concepts and algorithms. The simulation tool enables students to visualize the operation of finite automata, convert a regular expression into deterministic finite automata (DFA) or nondeterministic finite automata, and simulate Thompson's construction algorithm. The process of constructing the LL(0) and LR(1) parsing tables is represented as a step‐by‐step simulation, with the user receives feedback on the correctness of each step before moving on to the next. The system is capable of calculating the FIRST and FOLLOW sets, graphically representing DFA, and constructing the corresponding parsing table. This tool provides a module for visualizing the process of machine code generation. [ABSTRACT FROM AUTHOR]

Summary: Dynamic compilers perform compilation and generation of target code during runtime, implying that the compilation time is added into the program runtime. Thus, to build a high‐performing dynamic compilation system, it is crucial to be able to generate high‐quality code and, at the same time, have a small compilation cost. In this article, we present an approach that uses machine learning to select sequences of optimization for dynamic compilation that considers both code quality and compilation overhead. Our approach starts by training a model, offline, with a knowledge bank of those sequences with low overhead and high‐quality code generation capability using a genetic heuristic. Then, this bank is used to guide the smart selection of optimizations sequences for the compilation of code fragments during the emulation of an application. We evaluate the proposed strategy in two LLVM‐based dynamic binary translators, namely OI‐DBT and HQEMU, and show that these two translators can achieve average speedups of 1.26x and 1.15x in MiBench and Spec Cpu benchmarks, respectively. [ABSTRACT FROM AUTHOR]

Summary: As core counts in processors increases, it becomes harder to schedule and distribute work in a timely and scalable manner. This article enhances the scalability of parallel loop schedulers by specializing schedulers for fine‐grain loops. We propose a low‐overhead work distribution mechanism for a static scheduler that uses no atomic operations. We integrate our static scheduler with the Intel OpenMP and Cilkplus parallel task schedulers to build hybrid schedulers. Compiler support enables efficient reductions for Cilk, without changing the programming interface of Cilk reducers. Detailed, quantitative measurements demonstrate that our techniques achieve scalable performance on a 48‐core machine and the scheduling overhead is 43% lower than Intel OpenMP and 12.1× lower than Cilk. We demonstrate consistent performance improvements on a range of HPC and data analytics codes. Performance gains are more important as loops become finer‐grain and thread counts increase. We observe consistently 16%–30% speedup on 48 threads, with a peak of 2.8× speedup. [ABSTRACT FROM AUTHOR]

Copyright of Nachrichten aus der Chemie is the property of Wiley-Blackwell and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

We develop a new scheme for evaluating different molecular integrals using Gaussian type orbitals. In this new scheme, the evaluation of integrals is performed in two steps during runtime. The first step is a top-down procedure that maps each recurrence relation into a jagged array (array of arrays), where each element of a member array represents either the final results or some intermediate integrals that are stored in our developed data structure "coarse-grained circular buffer". This step is the same for all different one- and two-electron operators so that the same algorithm and source codes can be used. In the second step, a bottom-up procedure is carried out that computes all the intermediate and the final molecular integrals by backtracking elements from the last member array of each jagged array. Different source codes should in principle be used for different electron operators in the second step, but which can be generated automatically by our developed recurrence-relation compiler. The currently proposed general recurrence-relation generation scheme provides a new, generic and automatic programming way for various one- and two-electron integrals needed in computational chemistry. Users can even introduce new electron operators and evaluate their integrals during runtime by combining the implementation of the proposed new scheme and the just-in-time compilation technique. [ABSTRACT FROM AUTHOR]

Summary: Model‐based development (MBD) holds the promise to capture potential timing problems in embedded software during the early phases of the development, securing the production of bug‐free embedded software. For most MBD approaches, the source code is just an intermediate artifact that can be generated automatically from the models. This assumption clashes with an undeniable fact: a large share of the commercial embedded software exploits existing libraries or is developed using C/C++ natively. A way to reconcile the ambitions of MBD with the use of a programming language is by offering new language constructs and an innovative compilation tool‐chain that prevents model error and timing problems "by construction." However, the persistent popularity of C/C++ among embedded programmers and the limited availability of tools have severely limited the uptake of alternative programming languages for embedded software. Therefore, we propose an original route. Our language proposal, named Tice, has been shaped as a C++ active library. Tice retains full compatibility with existing C++ code, which can be integrated easily into new Tice‐based projects. The enforcement of Tice syntax and semantics can be made by a standard C++ compiler, forgoing the need for new tools. In this article, we describe Tice's syntax, semantics, and model of computation and communication. We demonstrate Tice's practical applicability on an industrial scale use‐case and give ample evidence for Tice's efficient compilation using off‐the‐shelf C++ compilers. Finally, we show Tice's code generation process. [ABSTRACT FROM AUTHOR]

Summary: In order to take advantage of the processing power of current computing platforms, programmers typically need to develop software versions for different target devices. This task is time‐consuming and requires significant programming and computer architecture expertise. A possible and more convenient alternative is to start with a single high‐level description of a program with minimum implementation details, and generate custom implementations according to the target platform. In this paper, we use MATLAB as a high‐level programming language and propose a compiler that targets CPU/GPU computing platforms by generating customized implementations in C and OpenCL. We propose a number of compiler techniques to automatically generate efficient C and OpenCL code from MATLAB programs. One of such compiler techniques relies on heuristics to decide when and how to use Shared Virtual Memory (SVM). The experimental results show that our approach is able to generate code that provides significant speedups (eg, geometric mean speedup of 11× for a set of simple benchmarks) using a discrete GPU over equivalent sequential C code executing on a CPU. With more complex benchmarks, for which only some code regions can be parallelized, and are thus offloaded, the generated code achieved speedups of up to 2.2×. We also show the impact of using SVM, specifically fine‐grained buffers, and the results show that the compiler is able to achieve significant speedups, both over the versions without SVM and with naïve aggressive SVM use, across three CPU/GPU platforms. [ABSTRACT FROM AUTHOR]

One of the fundamental topics in the education of students enrolled in computer‐related degrees is that of Boolean algebra. This is because it allows the expression of several problems related to digital design, artificial intelligence, databases, compilers, and formal languages, among others, as a sequence of Boolean operations and variables, which can be dealt with by using Boolean algebra methods to optimize algorithms, minimize digital components, and so forth. This study presents a piece of web‐based software, denominated as MiniBool, which has been developed with the objective of supporting the learning of Boolean algebra in a blended learning setting. This educational proposal gives students the opportunity to reinforce learning at any time and in any place. It additionally increases the learners' motivation by including gamification, through the use of a ranking that shows the students' level of participation. MiniBool was evaluated by means of a formal experiment, which was carried out with Discrete Mathematics students at a higher education institution in Mexico, where two groups were formed randomly: A control group, whose members attended classes and reinforced their knowledge in a traditional manner with a pencil and paper, and an experimental group, which learned in a blended learning context, receiving the same classes as the control group, but reinforcing what they had learned using MiniBool. The statistical results obtained indicate that the use of MiniBool has a positive and motivating effect on learning and that a greater academic performance is achieved than when the traditional teaching‐learning method is applied. [ABSTRACT FROM AUTHOR]

Summary: This article studies mini‐applications—Minisweep, GenASiS, GPP, and FF—that use computational methods commonly encountered in HPC. We have ported these applications to develop OpenACC and OpenMP versions, and evaluated their performance on Titan (Cray XK7 with K20x GPUs), Cori (Cray XC40 with Intel KNL), Summit (IBM AC922 with Volta GPUs), and Cori‐GPU (Cray CS‐Storm 500NX with Intel Skylake and Volta GPUs). Our goals are for these new ports to be useful to both application and compiler developers, to document and describe the lessons learned and the methodology to create optimized OpenMP and OpenACC versions, and to provide a description of possible migration paths between the two specifications. Cases where specific directives or code patterns result in improved performance for a given architecture are highlighted. We also include discussions of the functionality and maturity of the latest compilers available on the above platforms with respect to OpenACC or OpenMP implementations. [ABSTRACT FROM AUTHOR]

Summary: OpenSmalltalk‐VM is a virtual machine (VM) for languages in the Smalltalk family (eg, Squeak and Pharo), which is itself written in a subset of Smalltalk that can easily be translated to C. VM development is done in Smalltalk, an activity we call "simulation." The production VM is then derived by translating the core VM code to C. As a result, two execution models coexist: simulation, where the Smalltalk code is executed on top of a Smalltalk VM, and production, where the same code is compiled to an executable through a C compiler. The whole VM execution can be simulated: the heap is represented as a huge byte array, the VM code is executed as Smalltalk, and the native code generated by the just‐in‐time (JIT) compiler is executed by a processor simulator. All the Smalltalk development tools, such as the debugger, are then available while simulating. In addition, in simulation, it is also possible to use debugging features such as single stepping in the machine code generated by the JIT compiler. The Smalltalk development tools combined with the simulation debugging features provide developers with a productive environment in which to extend and debug the VM. In this article, we detail the VM simulation infrastructure and report our experiences developing and debugging VM features within it such as the garbage collector and the JIT compiler. [ABSTRACT FROM AUTHOR]

In this paper, we introduce Canis, a high‐level domain‐specific language that enables declarative specifications of data‐driven chart animations. By leveraging data‐enriched SVG charts, its grammar of animations can be applied to the charts created by existing chart construction tools. With Canis, designers can select marks from the charts, partition the selected marks into mark units based on data attributes, and apply animation effects to the mark units, with the control of when the effects start. The Canis compiler automatically synthesizes the Lottie animation JSON files [Aira], which can be rendered natively across multiple platforms. To demonstrate Canis' expressiveness, we present a wide range of chart animations. We also evaluate its scalability by showing the effectiveness of our compiler in reducing the output specification size and comparing its performance on different platforms against D3. [ABSTRACT FROM AUTHOR]

Instructors find it challenging to teach the compiler construction course, because the course introduces students to several abstract concepts and complex algorithms. Simulation tools enable students to visualize the theoretical concepts, give them a platform for experimentation, and provide them accurate results of their experiments instantaneously. This paper offers a review of 16 simulation systems suitable for teaching the compiler construction course. Evaluation criteria have been defined, and they have been used in the process of evaluation of the selected simulators. The results of the evaluation will be useful to instructors when choosing a simulator suitable for teaching their courses. [ABSTRACT FROM AUTHOR]

A Materials Acceleration Operation System (MAOS) is designed, with unique language and compiler architecture. MAOS integrates with virtual reality (VR), collaborative robots, and a reinforcement learning (RL) scheme for autonomous materials synthesis, properties investigations, and self‐optimized quality assurance. After training through VR, MAOS can work independently for labor and intensively reduces the time cost. Under the RL framework, MAOS also inspires the improved nucleation theory, and feedback for the optimal strategy, which can satisfy the demand on both of the CdSe quantum dots (QDs) emission wavelength and size distribution quality. Moreover, it can work well for extensive coverages of inorganic nanomaterials. MAOS frees the experimental researchers out of the tedious labor as well as the extensive exploration of optimal reaction conditions. This work provides a walking example for the "On‐Demand" materials synthesis system, and demonstrates how artificial intelligence technology can reshape traditional materials science research in the future. [ABSTRACT FROM AUTHOR]

Demand for microelectronics products has seen a recent explosion due to their increased adaption in high‐performance data storage, networking, and Internet of Things applications. Not only such products need to provide high performance, they are often integrated in mixed signal environments that include both analog and digital circuits. This has posed a challenge to faculty who teach microelectronics design in senior undergraduate and graduate electrical engineering courses. It is becoming increasingly difficult to upgrade microelectronics curricula, so students are enabled with the proper skills to utilize design tools presently common in the industry. This study provides a mechanism to integrate five state of the art design tools in one single design project. The tools are Custom Compiler, Hewlett Simulation Program with Integrated Circuit, verilog compiler simulator, IC Validator, and Design Complier. Students, through a design project, conduct the design, layout, and simulations of an static random‐access memory array. The project utilizes both the full‐custom and the semi‐custom flows. One full design is created and integrated where students do the design and layout of transistors in specific circuits and generate synthesized circuits automatically from a high‐level description language. This study can serve as a resource for senior undergraduate students, graduate students, faculty, and practicing engineers. Finally, it can help electrical engineering programs meet Accreditation Board for Engineering and Technology students' outcome (k) which is an ability to use the techniques, skills, and modern engineering tools necessary for engineering practice. [ABSTRACT FROM AUTHOR]

The Python programming language, combined with the numerical computing library NumPy and the scientific computing library SciPy, has become the de facto standard for scientific computing in a variety of fields. This popularity is mainly due to the ease with which a Python program can be written and executed (easy syntax, dynamical typing, no compilation etc.), coupled with the existence of a large number of specialized third‐party libraries that aim to lift all the limitations of the raw Python language. NumPy introduces vector programming, improving execution speeds, whereas SciPy brings a wealth of highly optimized and reliable scientific functions. There are cases, however, where vector programming alone is not sufficient to reach optimal performance. This issue is addressed with dedicated compilers that aim to translate Python code into native and statically typed code with support for the multi‐core architectures of modern processors. In the present article it is shown how these approaches can be efficiently used to tackle different problems, with increasing complexity, that are relevant to crystallography: the 2D Laue function, scattering from a strained 2D crystal, scattering from 3D nanocrystals and, finally, diffraction from films and multilayers. For each case, detailed implementations and explanations of the functioning of the algorithms are provided. Different Python compilers (namely NumExpr, Numba, Pythran and Cython) are used to improve performance and are benchmarked against state‐of‐the‐art NumPy implementations. All examples are also provided as commented and didactic Python (Jupyter) notebooks that can be used as starting points for crystallographers curious to enter the Python ecosystem or wishing to accelerate their existing codes. [ABSTRACT FROM AUTHOR]

Summary: On common processors, integer multiplication is many times faster than integer division. Dividing a numerator n by a divisor d is mathematically equivalent to multiplication by the inverse of the divisor (n/d=n∗1/d). If the divisor is known in advance, or if repeated integer divisions will be performed with the same divisor, it can be beneficial to substitute a less costly multiplication for an expensive division. Currently, the remainder of the division by a constant is computed from the quotient by a multiplication and a subtraction. However, if just the remainder is desired and the quotient is unneeded, this may be suboptimal. We present a generally applicable algorithm to compute the remainder more directly. Specifically, we use the fractional portion of the product of the numerator and the inverse of the divisor. On this basis, we also present a new and simpler divisibility algorithm to detect nonzero remainders. We also derive new tight bounds on the precision required when representing the inverse of the divisor. Furthermore, we present simple C implementations that beat the optimized code produced by state‐of‐the‐art C compilers on recent x64 processors (eg, Intel Skylake and AMD Ryzen), sometimes by more than 25%. On all tested platforms, including 64‐bit ARM and POWER8, our divisibility test functions are faster than state‐of‐the‐art Granlund‐Montgomery divisibility test functions, sometimes by more than 50%. [ABSTRACT FROM AUTHOR]

Summary: Programming modern embedded vision systems brings various challenges, due to the steep learning curve for programmers and the different characteristics of the devices. Quasar, a new high‐level programming language and development environment, considerably simplifies the development. Quasar has a compiler that detects and optimizes parallel programming patterns and a heterogeneous runtime that distributes the computational load over the available compute devices (CPUs and Graphical Processing Unit [GPUs]). In this paper, we focus on runtime aspects of Quasar. We show that with good approximation, the execution time of a GPU kernel function can be factorized in a compile‐time‐specific component and a runtime‐specific component. We show that this approximation leads to a computationally simple runtime load balancing rule. Moreover, the load balancing rule permits efficient implicit concurrency of kernel functions and automatic scaling to multiple compute devices (eg, multi‐CPU/GPU systems). Based on an appropriate mathematical scheduling model, we investigate the command queue size trade‐off between memory usage and device utilization. The result is a programming environment for embedded vision systems for which automatic parallelization and implicit concurrency detection allow scaling the program efficiently to multi‐CPU/GPU systems. Finally, benchmark results are provided to demonstrate the performance of our approach compared with OpenACC and CUDA (Compute Unified Device Architecture). [ABSTRACT FROM AUTHOR]

Summary: There is a strong prejudice against the friendship access control mechanism in C++. People claim that friendship breaks the encapsulation, reflects bad design, and creates too strong coupling. However, friends appear even in the most carefully designed systems, and if it is used judiciously (like using the attorney‐client idiom), they may be better choice than widening the public interface of the class. In this paper, we investigate how the friendship mechanism is used in C++ programs. We have made measurements on several open source projects to understand the current use of friends. Our results show various holes and errors in friend usage, like friend functions accessing only public members or not accessing members at all or the class, which declare friends has no private members at all. The results also show that friend functions actually use only a low percentage of the private members they were granted to access, which is a source of errors. These results have motivated us to propose a selective friend language construct for C++, which can restrict friendship only to well‐defined members. Such a new language element may decrease the degradation of encapsulation and significantly increase the diagnostic capacity of the compiler. We have created a proof‐of‐concept implementation based on the LLVM/Clang compiler infrastructure to show that such constructs can be established with a minimal syntactical and compilation overhead. [ABSTRACT FROM AUTHOR]

Summary: Using a central file server is good for interactive access to files, because of the coherency implied by a centralized design. In fact, within local area networks, this is a common case. However, distributed environments in use today may exhibit round‐trip times on the order of 50 or 100 ms. This is a problem for interactive file access to a central file server because of the resulting access times. Although aggressive caching and loosely synchronized replicas may be used for distributed file access, there are cases where the better coherency provided by a central server is still desirable. In this paper, we present ZX, a distributed file system and protocol designed with latency in mind. It can use caching, but it does not require caching or batching to address latency issues. ZX relies on a novel channel‐based file system interface. It includes find requests and leverages streaming requests to work well under high‐latency conditions. Unlike other protocols designed for distributed access to a central server, ZX tolerates round‐trip times on the order of 50 or 100 ms to access a central file server for interactive usage such as compiling shared sources, running binaries, editing documents, and other similar workloads. It can be used on UNIX using a FUSE adaptor while permitting native ZX speakers to run faster. [ABSTRACT FROM AUTHOR]

Verification of business processes typically relies on Petri net-based process models. While they allow for natural modeling and analysis of aspects such as parallelism and message exchange, such a process model is seldom complete and precise. This is mainly because the available techniques for deriving a Petri net model from the original model neglect process data in favor of feasible verification. In this paper, we present an approach for deriving more precise process models by leveraging a process-to-Petri-net compiler, which takes as input a business process and generates as output a Petri net model for the process. This can be subsequently used for verification. However, in contrast to a conventional compiler, our compiler's objective is not to create the most efficient code but rather to produce a most precise but still effectively verifiable Petri net-based process model. [ABSTRACT FROM AUTHOR]