Boost Library Research Articles

Critique of “A Parallel Framework for Constraint-Based Bayesian Network Learning via Markov Blanket Discovery” by SCC Team From ShanghaiTech University

In SC20, Srivastava <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">et al.</i> [6] proposed a Parallel F <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">ram</b> ework for <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">B</b> ayesian <bold xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">Le</b> arning, or ramBLe, for short, which is a highly parallel and efficient framework for learning the structure of Bayesian Networks (BNs) from samples, particularly large genome-scale networks. As part of our participation in the SC21 Student Cluster Competition, our task was to verify conclusions from the original work [6]. Here we present the outcome of our experiments, which were performed on a four-node cluster from the Oracle Cloud HPC platform. We reproduce the numerical results from [6], namely the algorithm's performance and scaling behavior using MPI and different Python and Boost libraries on the Oracle cloud.

BetheSF V2: 3-point propagator and additional external potentials

In a recent paper (Comput. Phys. Commun. 258 (2021) 107569) we obtained exactly the tagged-particle propagator in a single-file with N particels diffusing in a generic confining potential via the coordinate Bethe-Ansatz. A naïve implementation of this solution requires a non-polynomial algorithm. To speed-up the computation we implemented a more efficient algorithm that exploits the particle exchange-symmetry.In this new version we expand the code-base to allow for the computation of the three point Green's function. The latter is required e.g. in the analysis of the breaking of time-translational invariance. In addition we include the support for two canonical potentials of general interest: one presenting an energy barrier and one featuring an asymmetric potential landscape. New version program summaryProgram Title: BetheSFCPC Library link to program files:https://doi.org/10.17632/3bs74vf72n.2Licensing provisions: MITProgramming language: C++ (C++17 required), Boost 1.75.0 requiredJournal reference of previous version: Comput. Phys. Commun. 258 (2021) 107569Does the new version supersede the previous version?: YesReasons for new version: Computation of the three point Green's function, vectorized versions of the Green's functions, two new potentials included.Nature of problem: Diffusive single-files are mathematical models of effectively one-dimensional strongly correlated many-body systems. The diffusive dynamics of a tracer particle in a single-file has attracted widespread interest in the literature since it stands as a paradigm for non-Markovian and anomalous diffusion. The many-body Fokker-Planck equation governing the system's dynamics can be solved using the Coordinate Bethe Ansatz. The implementation of such a solution is notoriously challenging since it requires the generation of permutations.Solution method: Exploiting the underlining exchange symmetry among the particles of the system, it is possible to reduce the complexity of the algorithm for evaluating the tagged particle Green's function, in the best gain scenario, from O(N!) down to O(N), N being the size of the single-file.Summary of revisions:•We added support for the computation of the three point Green's function:G(xi,ta+τ;xi′,ta|x0i)=V00(x0i)−1∑k∑lV0k(xi)Vkl(xi′)Vl0(x0i)e−Λkτe−Λlta. Where the overlap elements Vkl(x) and the many-body eigenvalues Λk have been defined in the main article [1]. This function expresses the probability of the tagged-particle to end up in xi at time ta+τ, passing by xi′ and time ta conditioned to the fact that it started in x0i at time 0. This function is important for the study of breaking of the time-translation invariance in tagged particle dynamics [2]. Due to the presence of the term Vkl(x) the evaluation is time expensive. The code has been modified to allow for the computation of G(xi,ta+τ;xi′,ta|x0i).•We added functions that compute the two and the three point Green's functions at M different time-points but with the same spatial parameters. These new vectorized versions return a std::vector<double> containing the values of the Green's functions for several time-points. A single call of one of these new fuctions is faster than calling M times the corresponding previously implemented single-time-point function.•Solution for the square double well potential [3](1)U(x)={0,π>|x|>π/2f0,|x|≤π/2∞,otherwise; and for the asymmetric potential given by [4]:(2)U(x)=−(h−1)ln⁡(x)+x22 have been added in the files SingleFileBistable.hpp, SingleFileBistable.cpp and SingleFileGeneralizedBessel.hpp, SingleFileGeneralizedBessel.cpp respectively; the potentials are depicted in Fig. 1. The solution for the potential in Eq. (2) requires the computation of “special functions” related to the Gamma function and the hypergeometric function; these functions are provided either by the Boost library or can be found as template functions in the SpecialFunctions.hpp file. The potential (1) has been investigated in [3].

Formalising and implementing Boost POSIX regular expression matching

Whereas Perl-compatible regular expression matchers typically exhibit some variation of leftmost-greedy semantics, those conforming to the posix standard are prescribed leftmost-longest semantics. However, the posix standard leaves some room for interpretation, and Fowler and Kuklewicz have done experimental work to confirm differences between various posix matchers. The Boost library has an interesting take on the posix standard, where it maximises the leftmost match not with respect to subexpressions of the regular expression pattern, but rather, with respect to capturing groups. In our work, we provide the first formalisation of Boost semantics, analyze the complexity of regular expression matching when using Boost semantics, and provide efficient algorithms for both online and multipass matching.

MADHAT: Model-Agnostic Dark Halo Analysis Tool

We present the Model-Agnostic Dark Halo Analysis Tool (MADHAT), a numerical tool which implements a Fermi-LAT data-driven, model-independent analysis of gamma-ray emission from dwarf satellite galaxies and dwarf galaxy candidates due to dark matter annihilation, dark matter decay, or other nonstandard or unknown astrophysics. This tool efficiently provides statistical upper bounds on the number of observed photons in excess of the number expected, based on empirical determinations of foregrounds and backgrounds, using a stacked analysis of any selected set of dwarf targets. It also calculates the resulting bounds on the properties of dark matter under any assumptions the user makes regarding dark sector particle physics or astrophysics. As an application, we determine new bounds on Sommerfeld-enhanced dark matter annihilation in a set of eight dwarfs. MADHAT v1.0 includes 58 dwarfs and dwarf candidate targets, and we discuss future planned developments. MADHAT is available and will be maintained at https://github.com/MADHATdm. Program summaryProgram title: MADHATCPC Library link to program files: https://doi.org/10.17632/j4sd354jjr.1Developer’s repository link: https://github.com/MADHATdmLicensing provisions: MITProgramming language: C++Nature of problem: MADHAT is an efficient numerical tool that provides statistical limits on the number of observed photons coming from dark matter annihilation/decay or other nonstandard or unknown astrophysics by implementing a Fermi-LAT data-driven, model-independent analysis of gamma-ray emission from dwarf satellite galaxies and dwarf galaxy candidates.Solution method: MADHAT efficiently provides statistical upper bounds on the number of observed photons in excess of the number expected, based on empirical determinations of foregrounds and backgrounds, using a quick stacked analysis of any selected set of dwarf targets. The formalism relies on statistical estimates of the foreground/background gamma-ray flux along the observational line of sight. It also calculates the resulting bounds on the properties of dark matter under any assumptions the user makes regarding dark sector particle physics or astrophysics. MADHAT is dependent on Boost libraries.

Guided linking: dynamic linking without the costs

Dynamic linking is extremely common in modern software systems, thanks to the flexibility and space savings it offers. However, this flexibility comes at a cost: it’s impossible to perform interprocedural optimizations that involve calls to a dynamic library. The basic problem is that the run-time behavior of the dynamic linker can’t be predicted at compile time, so the compiler can make no assumptions about how such calls will behave. This paper introduces guided linking , a technique for optimizing dynamically linked software when some information about the dynamic linker’s behavior is known in advance. The developer provides an arbitrary set of programs, libraries, and plugins to our tool, along with constraints that limit the possible dynamic linking behavior of the software. By taking advantage of the constraints, our tool enables any existing optimization to be applied across dynamic linking boundaries. For example, the NoOverride constraint can be applied to a function when the developer knows it will never be overridden with a different definition at run time; guided linking then enables the function to be inlined into its callers in other libraries. We also introduce a novel code size optimization that deduplicates identical functions even across different parts of the software set. By applying guided linking to the Python interpreter and its dynamically loaded modules, supplying the constraint that no other programs or modules will be used, we increase speed by an average of 9%. By applying guided linking to a dynamically linked distribution of Clang and LLVM, and using the constraint that no other software will use the LLVM libraries, we can increase speed by 5% and reduce file size by 13%. If we relax the constraint to allow other software to use the LLVM libraries, we can still increase speed by 5% and reduce file size by 5%. If we use guided linking to combine 11 different versions of the Boost library, using minimal constraints, we can reduce the total library size by 57%.

Design and validation of a C++ code generator from Abstract State Machines specifications

AbstractAccording to best practices of model‐driven engineering, the implementation of a system should be obtained from its model through a systematic model‐to‐code transformation. We present in this paper a methodology supported by the Asm2C++ tool, which allows the users to generate C++ code from abstract state machine models. Thanks to Asm2C++, the implementation is generated in a seamless manner with an assurance of potential bug freeness of the generated code. Following the same approach, model‐based testing suggests deriving also (unit) tests from abstract models. We extend the Asm2C++ tool such that it can automatically produce unit tests for the generated code. Abstract test sequences, either generated randomly or through model checking, are translated to concrete C++ unit tests using the Boost library. In a similar manner, also, scenarios are generated in a behavior‐driven development (BDD) approach. To guarantee the correctness of the transformation process, we define a mechanism to test the correctness of the model‐to‐code transformation with respect to two main criteria: syntactical correctness and semantic correctness, which is based on the definition of conformance between the specification and the code. Using this approach, we have devised a process able to test the generated code by reusing unit tests. The process has been used to validate our model‐to‐code transformations.

Bubbleprofiler: Finding the field profile and action for cosmological phase transitions

We present BubbleProfiler, a C++ software package for finding field profiles in bubble walls and calculating the bounce action during phase transitions involving multiple scalar fields. Our code uses a recently proposed perturbative method for potentials with multiple fields and a shooting method for single field cases. BubbleProfiler is constructed with modularity, flexibility and practicality in mind. These principles extend from the input of an arbitrary potential with multiple scalar fields in various forms, through the code structure, to the testing suite. After reviewing the physics context, we describe how the methods are implemented in BubbleProfiler, provide an overview of the code structure and detail usage scenarios. We present a number of examples that serve as test cases of BubbleProfiler and comparisons to existing public codes with similar functionality. We also show a physics application of BubbleProfiler in the scalar singlet extension of the Standard Model of particle physics by calculating the action as a function of model parameters during the electroweak phase transition. BubbleProfiler completes an important link in the toolchain for studying the properties of the thermal phase transition driving baryogenesis and properties of gravitational waves in models with multiple scalar fields. The code can be obtained from: https://github.com/bubbleprofiler/bubbleprofiler. Program summaryProgram title:BubbleProfilerProgram files doi:http://dx.doi.org/10.17632/82y283ftz7.1Licensing provisions: GPLv3Programming language: C++External routines: Boost library, Eigen library, GNU Scientific Library, NLopt library, GiNaC libraryNature of problem: Find the field profile in the bubble wall (bounce solution) and Euclidean action for a cosmological phase transition by solving a set of coupled differential equations.Solution method: Direct shooting method for single field problems. Multiple field problems are solved using a perturbative algorithm which linearizes the bounce equations.Restrictions: Currently unable to find bounce solutions for potentials of more than one fields where the vacua are nearly degenerate — these are the so-called “thin walled” cases.Additional comments: Program Github repository https://github.com/bubbleprofiler/bubbleprofiler

Разработка среды программирования для мобильных устройств под управлением операционной системы Android

Mobile devices are frequently used for educational purposes considering their high availability and portability. However, educational abilities of mobile devices are quite limited due to the lack of proper IDE applications. Most Android integrated development environments for C++ are lacking code completion and real-time code analysis, while others provide these features at unacceptable speeds. Therefore, we decided to develop a next-generation mobile C++ IDE that will not only have these features, but will also provide them at real-time speeds. This will make mobile devices more suitable for learning C++ and will provide students with an opportunity to leave their laptops at home and to learn C++ in different situations, where usage of laptop is not convent. In this paper, we describe the software porting technology applied to Clang compiler and other required tools and propose the method to speed up compilation, code completion and code analysis in our IDE. We also propose UI optimization methods. We also describe a regular expression-based heuristic algorithm for precompiled header generation that has small processor time and RAM requirements. The efficiency of the algorithm is tested on different educational code examples. Our experiments show that our IDE is the only one at the moment, that can keep code completion real-time in all usage scenarios. The performance gain is 300 % average, when STL is used, reaching 3350 % when Boost library is involved. There is a small performance loss when C is used, but it is not significant, as the performance is still acceptable for real-time usage.

DAQ software for GEM-based imaging system

In the paper we report on the development of a dedicated data acquisition (DAQ) software being part of a full-filed X-ray fluorescence spectroscopy (XRF) imaging system based on a standard 10 cm × 10 cm 3-stage Gas Electron Multiplier (GEM) detector. Readout of a large area detector introduces additional constraints and requirements for the front-end electronics, data acquisition system and the software which are necessary for efficient system operation. The details of the front-end electronics and the data acquisition system have already been reported elsewhere. Therefore, in the paper, we focus mostly on the software part of the developed system. The software suite consists of a few independent components, each responsible for the well-defined task. A crucial part of the software, in a form of a Graphical User Interface (GUI) application written in modern C++ language with help of Qt framework and Boost libraries, is responsible for system configuration, monitoring and online data reconstruction. During data-taking periods an automated system is utilized for batch recording of the measurement data, event reconstruction and processing with results visualization. This part of the software has been split into (a) dedicated raw data recorder, (b) non-GUI event reconstruction component (C++ based) able to use most of the workstation resources (mainly CPUs time) and (c) independent, flexible offline visualization component for plots or histograms preparation (Python based). All the components of the system are completely independent of each other. Therefore, distribution of the tasks to a few workstation PCs is straightforward and significantly accelerates processing.

Hierarchical dynamic containers for fusion data

Scientific data can be naturally organized into hierarchical tree structures. One can find several examples of such a hierarchy, for example XML or JSON for general purpose and specifically HDF5 for scientific data. Data types in the EU-IM and IMAS frameworks are also organized into trees. Similarly, experimental data from fusion experiments have tree structures. We propose a new tree-structured data communication platform oriented mainly for integrated modelling and experimental data processing. This effort is part of our “Data Access and Provenance tools for the exploitation of EUROfusion experiments project” EUROfusion Engineering Grant.Our Hierarchical Dynamic Containers (HDC) library provides a similar functionality for in-core, shared memory communication as HDF5 does for files. Thus, the library enables fast yet easily manageable data exchange within multiple numerical codes (typical examples are integrated modelling workflow actors). HDC enables a zero data copy mechanism even across programming languages and processes. The tree structure is built around key-value storages, managed by a plug-in system. Thus users can choose from a variety of existing solutions of the underlying storage, including private, shared or distributed memory, persistent files or databases.The core library is written in C++11, highly leveraging the Boost library, and provides bindings for C, FORTRAN and Python (other languages are foreseen). The intent is to provide a clean, simple and universal API, that can be also used for unified access of files or databases. HDC is planned to be used in IMAS and for COMPASS, JET, MAST-U and TCV databases.

Parallel Implementations of RCM Algorithm for Bandwidth Reduction of Sparse Matrices

The Reverse Cuthill-McKee (RCM) algorithm is a well-known heuristicfor reordering sparse matrices. It is typically used to speed up the computation ofsparse linear systems of equations. This paper describes two parallel approachesfor the RCM algorithm as well as an optimized version of each one based on someproposed enhancements. The first one exploits a strategy for reducing lazy threads,while the second one makes use of a static bucket array as the main data structureand suppress some steps performed by the original algorithm. These related changesled to outstanding reordering time results and significant bandwidth reductions.The performance of two algorithms is compared with the respective implementationmade available by Boost library. The OpenMP framework is used for supportingthe parallelism and both versions of the algorithm are tested with large sparse andstructural symmetric matrices.

Parallel Implementations of RCM Algorithm for Bandwidth Reduction of Sparse Matrices

The Reverse Cuthill-McKee (RCM) algorithm is a well-known heuristic for reordering sparse matrices. It is typically used to speed up the computation of sparse linear systems of equations. This paper describes two parallel approaches for the RCM algorithm as well as an optimized version of each one based on some proposed enhancements. The first one exploits a strategy for reducing lazy threads, while the second one makes use of a static bucket array as the main data structure and suppress some steps performed by the original algorithm. These related changes led to outstanding reordering time results and significant bandwidth reductions. The performance of two algorithms is compared with the respective implementation made available by Boost library. The OpenMP framework is used for supporting the parallelism and both versions of the algorithm are tested with large sparse and structural symmetric matrices.

A resistive magnetohydrodynamics solver using modern C++ and the Boost library

In this paper we describe the implementation of our C++ resistive magnetohydrodynamics solver. The framework developed facilitates the separation of the code implementing the specific numerical method and the physical model from the handling of boundary conditions and the management of the computational domain. In particular, this will allow us to use finite difference stencils which are only defined in the interior of the domain (the boundary conditions are handled automatically). We will discuss this and other design considerations and their impact on performance in some detail. In addition, we provide a documentation of the code developed and demonstrate that a performance comparable to Fortran can be achieved, while still maintaining a maximum of code readability and extensibility. Program summaryProgram title: cppmhdCatalogue identifier: AFAH_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AFAH_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 592774No. of bytes in distributed program, including test data, etc.: 43771395Distribution format: tar.gzProgramming language: C++03.Computer: PC, HPC systems.Operating system: POSIX compatible (extensively tested on various Linux systems). In fact only the timing class requires POSIX routines; all other parts of the program can be run on any system where a C++ compiler, Boost, CVODE, and an implementation of BLAS are available.RAM: Hundredths of Kilobytes to Gigabytes (depending on the problem size)Classification: 19.10, 4.3.External routines: Boost, CVODE, either a BLAS library or Intel MKLNature of problem: An approximate solution to the equations of resistive magnetohydrodynamics for a given initial value and given boundary conditions is computed.Solution method: The discretization is performed using a finite difference approximation in space and the CVODE library in time (which employs a scheme based on the backward differentiation formulas).Restrictions: We consider the 2.5 dimensional case; that is, the magnetic field and the velocity field are three dimensional but all quantities depend only on x and y (but not z).Unusual features: We provide an implementation in C++ using the Boost library that combines high level techniques (which greatly increases code maintainability and extensibility) with performance that is comparable to Fortran implementations.Running time: From seconds to weeks (depending on the problem size).

Optimized Merge Sort on Modern Commodity Multi-core CPUs

Sorting is a kind of widely used basic algorithms. As the high performance computing devices are increasingly common, more and more modern commodity machines have the capability of parallel concurrent computing. A new implementation of sorting algorithms is proposed to harness the power of newer SIMD operations and multi-core computing provided by modern CPUs. The algorithm is hybrid by optimized bitonic sorting network and multi-way merge. New SIMD instructions provided by modern CPUs are used in the bitonic network implementation, which adopted a different method to arrange data so that the number of SIMD operations is reduced. Balanced binary trees are used in multi-way merge, which is also different with former implementations. Efforts are also paid on minimizing data moving in memory since merge sort is a kind of memory-bound application. The performance evaluation shows that the proposed algorithm is twice as fast as the sort function in C++ standard library when only single thread is used. It also outperforms radix sort implemented in Boost library.

Comprehensive Evaluation of a New GPU-based Approach to the Shortest Path Problem

The single-source shortest path (SSSP) problem arises in many different fields. In this paper, we present a GPU SSSP algorithm implementation. Our work significantly speeds up the computation of the SSSP, not only with respect to a CPU-based version, but also to other state-of-the-art GPU implementations based on Dijkstra. Both GPU implementations have been evaluated using the latest NVIDIA architectures. The graphs chosen as input sets vary in nature, size, and fan-out degree, in order to evaluate the behavior of the algorithms for different data classes. Additionally, we have enhanced our GPU algorithm implementation using two optimization techniques: The use of a proper choice of threadblock size; and the modification of the GPU L1 cache memory state of NVIDIA devices. These optimizations lead to performance improvements of up to 23 % with respect to the non-optimized versions. In addition, we have made a platform comparison of several NVIDIA boards in order to distinguish which one is better for each class of graphs, depending on their features. Finally, we compare our results with an optimized sequential implementation of Dijkstra's algorithm included in the reference Boost library, obtaining an improvement ratio of up to 19$$\times $$× for some graph families, using less memory space.

FlexibleSUSY—A spectrum generator generator for supersymmetric models

We introduce FlexibleSUSY, a Mathematica and C++ package, which generates a fast, precise C++ spectrum generator for any SUSY model specified by the user. The generated code is designed with both speed and modularity in mind, making it easy to adapt and extend with new features. The model is specified by supplying the superpotential, gauge structure and particle content in a SARAH model file; specific boundary conditions e.g. at the GUT, weak or intermediate scales are defined in a separate FlexibleSUSY model file. From these model files, FlexibleSUSY generates C++ code for self-energies, tadpole corrections, renormalization group equations (RGEs) and electroweak symmetry breaking (EWSB) conditions and combines them with numerical routines for solving the RGEs and EWSB conditions simultaneously. The resulting spectrum generator is then able to solve for the spectrum of the model, including loop-corrected pole masses, consistent with user specified boundary conditions. The modular structure of the generated code allows for individual components to be replaced with an alternative if available. FlexibleSUSY has been carefully designed to grow as alternative solvers and calculators are added. Predefined models include the MSSM, NMSSM, E6SSM, USSM, R-symmetric models and models with right-handed neutrinos. Program SummaryProgram title: FlexibleSUSYCatalogue identifier: AEVI_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEVI_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU General Public License, version 3No. of lines in distributed program, including test data, etc.: 129406No. of bytes in distributed program, including test data, etc.: 854831Distribution format: tar.gzProgramming language: C++, Wolfram/Mathematica, FORTRAN, Bourne shell.Computer: Personal computer.Operating system: Tested on Linux 3.x, Mac OS X.Classification: 11.1, 11.6, 6.5.External routines: SARAH 4.0.4, Boost library, Eigen, LAPACKNature of problem: Determining the mass spectrum and mixings for any supersymmetric model. The generated code must find simultaneous solutions to constraints which are specified at two or more different renormalization scales, which are connected by renormalization group equations forming a large set of coupled first-order differential equations.Solution method: Nested iterative algorithm and numerical minimization of the Higgs potential.Restrictions: The couplings must remain perturbative at all scales between the highest and the lowest boundary condition. FlexibleSUSY assumes that all couplings of the model are real (i.e. CP-conserving). Due to the modular nature of the generated code, adaption and extension to overcome restrictions in scope is quite straightforward.Running time: 0.06–0.2 seconds per parameter point.

Research on the Multi Object Polymorphism in C++ Based on Display Management Overloaded Set

In C++, there exists static dispatching technique and dynamic dispatching technique. To move some dispatching at executive time up to compile time can reduce length of complied code and improve the overall running speed. We analyze the necessity of introducing static dispatching technique and those used commonly, and then we present a way to realize static dispatching technique by using enable if template group in Boost library non-intrusively explicitly to manage the overloaded set of template functions. More importantly, in this way, one could overload template functions by their return values.

Research on the Static Dispatching in C++ Based on Display Management Overloaded Set

In C++, there exists static dispatching technique and dynamic dispatching technique. To move some dispatching at executive time up to compile time can reduce length of complied code and improve the overall running speed. We analyze the necessity of introducing static dispatching technique and those used commonly, and then we present a way to realize static dispatching technique by using enable_if template group in Boost library non-intrusively explicitly to manage the overloaded set of template functions. More importantly, in this way, one could overload template functions by their return values.

New features of C++11

C++ is a programming language commonly taught in the undergraduate Computer Science curriculum. Recently the long awaited new standard for C++ known as C++11 was adopted replacing the C++98/C++03 standard. C++11 source code is backward compatible with the first standard source code. Many of the changes were strongly influenced by the TR1 and the Boost library. The new language features include scoped enumerations, the auto and decltype keywords, lambdas, variadic templates, raw strings, a range based for loop, and initializer lists. Many changes involve the Standard C++ Library. Of particular note are templates for tuples, smart pointers (shared_ptr, unique_ptr and weak_ptr), arrays, forward lists, unordered sets and maps, regular expressions, and sophisticated random number generation support.

PREDATOR

False sharing is a notorious problem for multithreaded applications that can drastically degrade both performance and scalability. Existing approaches can precisely identify the sources of false sharing, but only report false sharing actually observed during execution; they do not generalize across executions. Because false sharing is extremely sensitive to object layout, these detectors can easily miss false sharing problems that can arise due to slight differences in memory allocation order or object placement decisions by the compiler. In addition, they cannot predict the impact of false sharing on hardware with different cache line sizes. This paper presents PREDATOR, a predictive software-based false sharing detector. PREDATOR generalizes from a single execution to precisely predict false sharing that is latent in the current execution. PREDATOR tracks accesses within a range that could lead to false sharing given different object placement. It also tracks accesses within virtual cache lines, contiguous memory ranges that span actual hardware cache lines, to predict sharing on hardware platforms with larger cache line sizes. For each, it reports the exact program location of predicted false sharing problems, ranked by their projected impact on performance. We evaluate PREDATOR across a range of benchmarks and actual applications. PREDATOR identifies problems undetectable with previous tools, including two previously-unknown false sharing problems, with no false positives. PREDATOR is able to immediately locate false sharing problems in MySQL and the Boost library that had eluded detection for years.