Multithreaded Code Research Articles

The polychronous model of computation and Kahn process networks

In 1974, Gilles Khan defined a seminal semantic model for asynchronous dataflow programming that would then be called as the eponymous Kahn process networks (KPN) and instantiated in as many models of the so-called DPN hierarchy as domain-specific fields of information processing from digital signal processing to hybrid cyber-physical systems. Among these, synchronous programming models have had an important impact in the specific domain of embedded software design. In this paper, we consider an instance of what seems to be one of the many synchronous models of computation: polychrony, initiated by the dataflow language Signal and its multi-clock (i.e. polychronous) model of computation and, later on, CCSL (clock constraints specification language). We provide an in-depth study of its semantic relationship with respect to the original definition of KPNs and hint toward the idea of polychrony as a methodology to locally synchronize (abstractions of) globally asynchronous processes. In particular, we formally define the property, referred to as “polyendochrony”, that allows one to consider a given desynchronized network of synchronous Signal processes (a GALS architecture) as the implementation of a corresponding KPN model (an asynchronous network of Khan-deterministic functions). For this class of networks, we formalize the Signal program analysis and transformations that define synchronous clusters of Signal processes of guaranteed deterministic behavior in an asynchronous network, that is, without synchronizing communications in the entire network. This definition yields a new strategy of multi-threaded code generation that is available in the open-source Polychrony toolset of the Signal language and blurs the limits between the asynchronous and polychronous models of computation.

CREATING MULTITHREADED PTOGRAMS IN C++

For many years, the increase in computing power of modern devices is achieved not by increasing the clock frequency and bandwidth of CPUs, but by using hyper-threaded and multicore architectures. This simple change in approach to the CPU design led to dramatic changes in the organization of computing and became a turning point for software developers. Software that is going to take advantage of the increased computing power of multi-core architectures must be designed to be able to perform multiple tasks simultaneously. When covering the topic of parallel/simultaneous computing, scientists and IT professionals use two terms: (1) parallelism and (2) concurrency. A third important term when considering parallel/simultaneous computing is “multithreading”. In C++, the two most common ways to implement parallelism are concurrency and parallelism itself. Although they can be used in other programming languages, C++ stands out for its ability to use concurrent computations with lower-than-average utilization of general machine resources, as well as its ability to execute complex instructions. The C++11 standard introduced support for multi-threaded programs. The C++ standard recognized the existence of multithreading in the language and provided components for writing multithreaded programs in the <thread> library. This made it possible to write multithreaded programs in C++ without relying on platform-specific extensions and enabled the creation of portable multithreaded code with guaranteed behavior. The <thread> library provides extensive opportunities for organizing parallel and concurrent calculations, it also contains the C++ memory model, conditional variables, mutexes, etc. for thread synchronization. The article analyzes the possibilities of writing programs in the C++ using multiple threads for parallel and concurrent execution of tasks. It also considers the features of the C++ and the tools of the <thread> library that make parallelism and concurrency possible.

Stateful Serverless Computing with Crucial

Serverless computing greatly simplifies the use of cloud resources. In particular, Function-as-a-Service (FaaS) platforms enable programmers to develop applications as individual functions that can run and scale independently. Unfortunately, applications that require fine-grained support for mutable state and synchronization, such as machine learning (ML) and scientific computing, are notoriously hard to build with this new paradigm. In this work, we aim at bridging this gap. We present Crucial , a system to program highly-parallel stateful serverless applications. Crucial retains the simplicity of serverless computing. It is built upon the key insight that FaaS resembles to concurrent programming at the scale of a datacenter. Accordingly, a distributed shared memory layer is the natural answer to the needs for fine-grained state management and synchronization. Crucial allows to port effortlessly a multi-threaded code base to serverless, where it can benefit from the scalability and pay-per-use model of FaaS platforms. We validate Crucial with the help of micro-benchmarks and by considering various stateful applications. Beyond classical parallel tasks (e.g., a Monte Carlo simulation), these applications include representative ML algorithms such as k -means and logistic regression. Our evaluation shows that Crucial obtains superior or comparable performance to Apache Spark at similar cost (18%–40% faster). We also use Crucial to port (part of) a state-of-the-art multi-threaded ML library to serverless. The ported application is up to 30% faster than with a dedicated high-end server. Finally, we attest that Crucial can rival in performance with a single-machine, multi-threaded implementation of a complex coordination problem. Overall, Crucial delivers all these benefits with less than 6% of changes in the code bases of the evaluated applications.

PyOMP: Multithreaded Parallel Programming in Python

Python is a widely used language in scientific computing. When the goal is high performance, however, Python lags far behind low-level languages such as C and Fortran. To support applications that stress performance, Python needs to access the full capabilities of modern CPUs. That means support for parallel multithreading. In this article, we describe PyOMP, a system that enables OpenMP in Python. Programmers write code in Python with OpenMP, Numba generates code that compiles to LLVM, and the resulting programs run with performance that approaches that from code written with C and OpenMP. In this article, we provide an update on the PyOMP project and explain how to install it and use it to write parallel multithreaded code in Python.

Evaluation of automatic parallelization algorithms to minimize speculative parallelism overheads: An experiment

Automatic parallelization is a crucial objective of the parallel computing architecture that can be achieved through conversion of sequential code into multi-threaded code, which will run in parallel manner. This approach focuses largely on the loops since they take most of the execution time in programs. Thread level speculation techniques come into roleplay while checking for the dependencies. These dependencies cannot be identified at the compile time, thus providing a larger scope of parallelization when combined with other parallelisation techniques. This results in a greater speedup and more accurate parallel code formation. In this research paper, an experiment to evaluate the performance and comparative analysis has been done among key automatic parallelization algorithms on different parameters like number of cores, speedup and loop dependency taking into consideration of speculation.

Dose divergence between monte carlo simulation and experimental measurements in the build-up region for a photon beam

The aim of this work was to study the divergence between simulation and experimental measurements in the build-up region using two types of medical accelerators Elekta Synergy MLCi2 and Varian clinac 2100C and also for two types of ionization chambers. The Monte Carlo simulation was performed using the G4Linac-MT code. By demonstrating the variation of the particles in the build-up region, this work allows us to give an exact conclusion on the divergence between the Monte Carlo simulation and the experimental measurements.Using multi-threading code G4Linac-MT and the performance of the HPC-Marwan computing grid, we carried out simulations of large events with a saving in computing time. After optimizing the initial beam parameters, we looked for the ideal voxel size which corresponds to a better agreement between simulation and measurements to avoid simulation errors. The divergence between simulation and measurements in the build-up region is studied according to the type of ionization chamber, the irradiation fields, the source-to-surface distance (SSD) and the photon energy.The results obtained indicate that the dose divergence in the build-up region increases with the appearance of the contamination particles. The secondary particles detected in the build-up region are electrons and positrons for the 6 MV photon beam and other particles are added for the high energy beam 18 MV, including protons and neutrons. The dose accuracy of the comparison between the simulation and the measurements of the Varian 2100C and Elekta Synergy MLCi2 accelerators increases if the voxel size is small. A good agreement between the simulation and the experimental measurements in the build-up region is that which shows almost stable contamination of the particles up to the depth of electronic equilibrium.

Efficient Memory Arbitration in High-Level Synthesis From Multi-Threaded Code

High-level synthesis (HLS) is an increasingly popular method for generating hardware from a description written in a software language like C/C++. Traditionally, HLS tools have operated on sequential code, however in recent years there has been a drive to synthesise multi-threaded code. In this context, a major challenge facing HLS tools is how to automatically partition memory among parallel threads to fully exploit the bandwidth available on an FPGA device and minimise memory contention. Existing partitioning approaches require inefficient arbitration circuitry to serialise accesses to each bank because they make conservative assumptions about which threads might access which memory banks. In this article, we design a static analysis that can prove certain memory banks are only accessed by certain threads, and use this analysis to simplify or even remove the arbiters while preserving correctness. We show how this analysis can be implemented using the Microsoft Boogie verifier on top of satisfiability modulo theories (SMT) solver, and propose a tool named EASY using automatic formal verification. Our work supports arbitrary input code with any irregular memory access patterns and indirect array addressing forms. We implement our approach in LLVM and integrate it into the LegUp HLS tool. For a set of typical application benchmarks our results have shown that EASY can achieve 0.13× (avg. 0.43×) of area and 1.64× (avg. 1.28×) of performance compared to the baseline, with little additional compilation time relative to the long time in hardware synthesis.

Reducing WCET Overestimations in Multi-Thread Loops with Critical Section Usage

Worst-case execution time (WCET) is an important metric in real-time systems that helps in energy usage modeling and predefined execution time requirement evaluation. While basic timing analysis relies on execution path identification and its length evaluation, multi-thread code with critical section usage brings additional complications and requires analysis of resource-waiting time estimation. In this paper, we solve a problem of worst-case execution time overestimation reduction in situations when multiple threads are executing loops with the same critical section usage in each iteration. The experiment showed the worst-case execution time does not take into account the proportion between computational and critical sections; therefore, we proposed a new worst-case execution time calculation model to reduce the overestimation. The proposed model results prove to reduce the overestimation on average by half in comparison to the theoretical model. Therefore, this leads to more accurate execution time and energy consumption estimation.

Validation of Monte carlo Geant4 multithreading code for a 6 MV photon beam of varian linac on the grid computing.

To evaluate the computation time efficiency of the multithreaded code (G4Linac-MT) in the dosimetry application, using the high performance of the HPC-Marwan grid to determine with high accuracy the initial parameters of the 6 MV photon beam of Varian CLINAC 2100C. The difficulty of Monte Carlo methods is the long computation time, this is one of the disadvantages of the Monte Carlo methods. Calculations are performed by the multithreaded code G4Linac-MT and Geant4.10.04.p02 using the HPC-Marwan computing grid to evaluate the computing speed for each code. The multithreaded version is tested in several CPUs to evaluate the computing speed according to the number of CPUs used. The results were compared to the measurements using different types of comparisons, TPR20.10, penumbra, mean dose error and gamma index. The results obtained for this work indicate a much higher computing time saving for the G4Linac-MT version compared to the Geant4.10.04 version, the computing time decreases with the number of CPUs used, can reach about 12 times if 64CPUs are used. After optimization of the initial electron beam parameters, the results of the dose simulations obtained for this work are in very good agreement with the experimental measurements with a mean dose error of up to 0.41% on the PDDs and 1.79% on the lateral dose. The gain in computation time leads us to perform Monte Carlo simulations with a large number of events which gives a high accuracy of the dosimetry results obtained in this work.

Multithreaded scheduling for program segments based on chemical reaction optimizer

Multicore processors that support multithreading techniques have many advantages, including processors’ utilization, responsiveness, resource sharing, and economical usage of threads. Thus, to have these advantages, programming languages must support multithreading programming. Unfortunately, this technique is not compatible with old programs since most of the old program codes have been prepared sequentially. Inevitably, this posed a challenge when attempts were made to convert old sequential codes into multithreading codes. Despite the existence of several approaches of multithreading, differences do exist in their overhead, efficiency, and speedup, thereby underpinning the need for further optimization. Thus, a chemical reaction optimizer demonstrates the efficacy of its optimization in several problems. Against this backdrop, this paper presents a chemical reaction optimizer for the multithreading scheduling (CROTS) technique that generates multithreaded code while considering a sequential one. CROTS technique has been evaluated using several performance metrics, such as the number of steps, execution time, speedup, efficiency, cost, and percentage of error. Experimental results show that the maximum speedup achieved by CROTS is 11.98 upon the usage of 32 threads, with an average percentage of error being 14.56% in regard to the comparison between experimental and analytical cost results. Furthermore, after comparing CROTS with intermediate representation based on diKernel (KIR), it has been established that it can accommodate more threads and attain greater speedup. For example, the experiments show that when applying both approaches CROTS and KIR using 32 threads on dataset M7000, CROTS attains a speedup of 11.71, that is, about tripled the speedup achieved by KIR, which is 3.77.

Alternating direction implicit time integrations for finite difference acoustic wave propagation: Parallelization and convergence

This work studies the parallelization and empirical convergence of two finite difference acoustic wave propagation methods on 2-D rectangular grids, that use the same alternating direction implicit (ADI) time integration. This ADI integration is based on a second-order implicit Crank-Nicolson temporal discretization that is factored out by a Peaceman-Rachford decomposition of the time and space equation terms. In space, these methods highly diverge and apply different fourth-order accurate differentiation techniques. The first method uses compact finite differences (CFD) on nodal meshes that requires solving tridiagonal linear systems along each grid line, while the second one employs staggered-grid mimetic finite differences (MFD). For each method, we implement three parallel versions: (i) a multithreaded code in Octave, (ii) a C++ code that exploits OpenMP loop parallelization, and (iii) a CUDA kernel for a NVIDIA GTX 960 Maxwell card. In these implementations, the main source of parallelism is the simultaneous ADI updating of each wave field matrix, either column-wise or row-wise, according to the differentiation direction. In our numerical applications, the highest performances are displayed by the CFD and MFD CUDA codes that achieve speedups of 7.21x and 15.81x, respectively, relative to their C++ sequential counterparts with optimal compilation flags. Our test cases also allow to assess the numerical convergence and accuracy of both methods. In a problem with exact harmonic solution, both methods exhibit convergence rates close to 4 and the MDF accuracy is practically higher. Alternatively, both convergences decay to second order on smooth problems with severe gradients at boundaries, and the MDF rates degrade in highly-resolved grids leading to larger inaccuracies. This transition of empirical convergences agrees with the nominal truncation errors in space and time.

FullSimLight: ATLAS standalone Geant4 simulation

HEP experiments simulate the detector response by accessing all needed data and services within their own software frameworks. However decoupling the simulation process from the experiment infrastructure can be useful for a number of tasks, amongst them the debugging of new features, or the validation of multi-threaded vs sequential simulation code and the optimization of algorithms for HPCs. The relevant features and data must be extracted from the framework to produce a standalone simulation application. As an example, the simulation of the detector response of the ATLAS experiment at the LHC is based on the Geant4 toolkit and is fully integrated in the experiment’s framework “Athena”. Recent developments opened the possibility of accessing a full persistent copy of the ATLAS geometry outside of the Athena framework. This is a prerequisite for running ATLAS Geant4 simulation standalone. In this paper we present the status of development of FullSimLight, a lightweight simulation prototype that is being developed with the goal of running ATLAS standalone Geant4 simulation with the actual ATLAS geometry. The purpose of FullSimLight is to simplify studies of Geant4 tracking and physics processes, including tests on novel architectures. We will also address the challenges related to the complexity of ATLAS’s geometry implementation, which precludes make persistent a complete detector description in a way that can be automatically read by standalone Geant4. This lightweight prototype is meant to ease debugging operations on the Geant4 side and to allow early testing of new Geant4 releases. It will also ease optimization studies and R&D activities related to HPC development: i.e. the possibility to offload partially/totally the simulation to GPUs/Accelerators without having to port the whole experimental infrastructure.

G4Linac_MT, an easy-to-use Geant4-based code for modeling medical linear accelerator

In this paper, we present G4Linac_MT, a simple-to-use open source code developed to facilitate the use of the Geant4 C++ toolkit for the simulation of a medical linear accelerator (linac). This multithreaded code encapsulates several well-developed C++ modules serving to handle the complexity of coding geometry and material, to easy plot histograms of various physics quantities, to auto-merge output data created by all working threads into a single file, to well-estimate the number of simulated primary particles required to achieve data with a statistical uncertainty < 1% and also the CPU time required for, to use a set of variance reduction techniques as bremsstrahlung splitting, particle recycling, particle rotational splitting and stacking mechanism, to use a new format of phase space file based on HDF5-C++ scientific library which has been developed specially for this code. In order to minimize human effort required by Geant4 coding and validating of a linac, the code comes with a Java-based GUI application which contains separated GUI modules for linac head simulation, dose calculation, data analysis, geometry modeling and gamma index calculation. Results from Monte Carlo simulations of linac head of a Saturne 43 12 MV configuring a 10 × 10 cm2 radiation field are showed in order to demonstrate the G4Linac_MT capabilities. Thus, comparisons between simulated dosimetric functions and measured ones in a water phantom have been established by using a gamma index method and the results show a good agreement within 2.6%-1 mm accuracy. In addition, after optimizing variance reduction techniques, the overall CPU time spent by this multithreaded code has been decreased by a factor of 7.

Automated Orthorectification of VHR Satellite Images by SIFT-Based RPC Refinement

Raw remotely sensed images contain geometric distortions and cannot be used directly for map-based applications, accurate locational information extraction or geospatial data integration. A geometric correction process must be conducted to minimize the errors related to distortions and achieve the desired location accuracy before further analysis. A considerable number of images might be needed when working over large areas or in temporal domains in which manual geometric correction requires more labor and time. To overcome these problems, new algorithms have been developed to make the geometric correction process autonomous. The Scale Invariant Feature Transform (SIFT) algorithm is an image matching algorithm used in remote sensing applications that has received attention in recent years. In this study, the effects of the incidence angle, surface topography and land cover (LC) characteristics on SIFT-based automated orthorectification were investigated at three different study sites with different topographic conditions and LC characteristics using Pleiades very high resolution (VHR) images acquired at different incidence angles. The results showed that the location accuracy of the orthorectified images increased with lower incidence angle images. More importantly, the topographic characteristics had no observable impacts on the location accuracy of SIFT-based automated orthorectification, and the results showed that Ground Control Points (GCPs) are mainly concentrated in the “Forest” and “Semi Natural Area” LC classes. A multi-thread code was designed to reduce the automated processing time, and the results showed that the process performed 7 to 16 times faster using an automated approach. Analyses performed on various spectral modes of multispectral data showed that the arithmetic data derived from pan-sharpened multispectral images can be used in automated SIFT-based RPC orthorectification.

Multi-threading performance of Geant4, MCNP6, and PHITS Monte Carlo codes for tetrahedral-mesh geometry

In this study, the multi-threading performance of the Geant4, MCNP6, and PHITS codes was evaluated as a function of the number of threads (N) and the complexity of the tetrahedral-mesh phantom. For this, three tetrahedral-mesh phantoms of varying complexity (simple, moderately complex, and highly complex) were prepared and implemented in the three different Monte Carlo codes, in photon and neutron transport simulations. Subsequently, for each case, the initialization time, calculation time, and memory usage were measured as a function of the number of threads used in the simulation. It was found that for all codes, the initialization time significantly increased with the complexity of the phantom, but not with the number of threads. Geant4 exhibited much longer initialization time than the other codes, especially for the complex phantom (MRCP). The improvement of computation speed due to the use of a multi-threaded code was calculated as the speed-up factor, the ratio of the computation speed on a multi-threaded code to the computation speed on a single-threaded code. Geant4 showed the best multi-threading performance among the codes considered in this study, with the speed-up factor almost linearly increasing with the number of threads, reaching ~30 when N = 40. PHITS and MCNP6 showed a much smaller increase of the speed-up factor with the number of threads. For PHITS, the speed-up factors were low when N = 40. For MCNP6, the increase of the speed-up factors was better, but they were still less than ~10 when N = 40. As for memory usage, Geant4 was found to use more memory than the other codes. In addition, compared to that of the other codes, the memory usage of Geant4 more rapidly increased with the number of threads, reaching as high as ~74 GB when N = 40 for the complex phantom (MRCP). It is notable that compared to that of the other codes, the memory usage of PHITS was much lower, regardless of both the complexity of the phantom and the number of threads, hardly increasing with the number of threads for the MRCP.

Performance optimizations for scalable CFD applications on hybrid CPU+MIC heterogeneous computing system with millions of cores

For computational fluid dynamics (CFD) applications with a large number of grid points/cells, parallel computing is a common efficient strategy to reduce the computational time. How to achieve the best performance in the modern supercomputer system, especially with heterogeneous computing resources such as hybrid CPU+GPU, or a CPU + Intel Xeon Phi (MIC) co-processors, is still a great challenge.An in-house parallel CFD code capable of simulating three dimensional structured grid applications is developed and tested in this study. Several methods of parallelization, performance optimization and code tuning both in the CPU-only homogeneous system and in the heterogeneous system are proposed based on identifying potential parallelism of applications, balancing the work load among all kinds of computing devices, tuning the multi-thread code toward better performance in intra-machine node with hundreds of CPU/MIC cores, and optimizing the communication among inter-nodes, inter-cores, and between CPUs and MICs.Some benchmark cases from model and/or industrial CFD applications are tested on the Tianhe-1A and Tianhe-2 supercomputer to evaluate the performance. Among these CFD cases, the maximum number of grid cells reached 780 billion. The tuned solver successfully scales up to half of the entire Tianhe-2 supercomputer system with over 1.376 million of heterogeneous cores. The test results and performance analysis are discussed in detail.

A Comparative Study between Applications Developed for Android and iOS

Now-a-days, mobile applications implement complex functionalities that use device’s core features extensively. This paper realizes a performance analysis of the most important core features used frequently in mobile application development: asynchronous multi-threaded code execution, drawing views/elements on the screen and basic network communications. While multiple mobile platforms have emerged in recent years, in this paper two well-established and popular operating systems were considered for comparison and testing: Android and iOS. Thus, two basic applications featuring the same functionality and complexity were developed to run natively on both platforms. Applications were developed by using development languages and tools recommended for each operating system. This paper aims to highlight the differences between the two operating systems by analyzing core feature performance metrics for both functionally identical mobile applications developed for each platform. Results obtained could be further used for guiding the optimization of application’s development process for each considered operating system.

A new implementation of itk::ImageToImageFilter for efficient parallelization of image processing algorithms using Intel Threading Building Blocks

Modern medical imaging makes use of high performance computing to accelerate image acquisition, image reconstruction, image visualization and image analysis. Software libraries that provide implementations of key medical imaging algorithms need to efficiently exploit modern CPU architectures. In particular, workstations with small numbers of cores are being replaced by very high core count architectures, and by many integrated core architectures, which offer acceleration by vectorization and multi-threading.The Insight Toolkit (ITK) is the premier open source implementation of medical imaging algorithms, with a generic design for image processing filters that allows for many developers to rapidly incorporate these algorithms in to new applications. While ITK filters benefit from a generic, platform independent multithreading capability, the current implementation is difficult to exploit to achieve very high performance. Specifically, ITK relies on a static decomposition of the image into subsets of equal size which can be highly inefficient. Threads that terminate early due to uneven work throughout the image finish early and do not contribute further to the processing of more complex regions, leading to idle computational resources and longer execution times. Performance is also difficult to coordinate across multiple algorithms, as the ITK filter assumes each filter operates independently but the global implementation has an impact across filters.In this work, we propose a novel, simple to use, high performance multithreading capability for ITK that accelerates the itk::ImageToImageFilter. We utilise a workpile data decomposition strategy, and leave the task of optimal job scheduling on CPU cores to the library called Threading Building Blocks (TBB). We demonstrate the efficacy of multi-threading with TBB in comparison to the itk::Multithreader class, through three simple example image analysis algorithms.Our implementation provides a new multi-threaded itk::ImageToImageFilter that can be conveniently reused to provide simple and efficient multi-threaded code across applications and algorithm libraries. Our new implementation is distributed as open-source software to the community and is straightforward to adopt.

TU-AB-BRC-10: Modeling of Radiotherapy Linac Source Terms Using ARCHER Monte Carlo Code: Performance Comparison of GPU and MIC Computing Accelerators

Purpose: (1) To perform phase space (PS) based source modeling for Tomotherapy and Varian TrueBeam 6 MV Linacs, (2) to examine the accuracy and performance of the ARCHER Monte Carlo code on a heterogeneous computing platform with Many Integrated Core coprocessors (MIC, aka Xeon Phi) and GPUs, and (3) to explore the software micro-optimization methods. Methods: The patient-specific source of Tomotherapy and Varian TrueBeam Linacs was modeled using the PS approach. For the helical Tomotherapy case, the PS data were calculated in our previous study (Su et al. 2014 41(7) Medical Physics). For the single-view Varian TrueBeam case, we analytically derived them from the raw patient-independent PS data in IAEA's database, partial geometry information of the jaw and MLC as well as the fluence map. The phantom was generated from DICOM images. The Monte Carlo simulation was performed by ARCHER-MIC and GPU codes, which were benchmarked against a modified parallel DPM code. Software micro-optimization was systematically conducted, and was focused on SIMD vectorization of tight for-loops and data prefetch, with the ultimate goal of increasing 512-bit register utilization and reducing memory access latency. Results: Dose calculation was performed for two clinical cases, a Tomotherapy-based prostate cancer treatment and a TrueBeam-based left breast treatment. ARCHER was verified against the DPM code. The statistical uncertainty of the dose to the PTV was less than 1%. Using double-precision, the total wall time of the multithreaded CPU code on a X5650 CPU was 339 seconds for the Tomotherapy case and 131 seconds for the TrueBeam, while on 3 5110P MICs it was reduced to 79 and 59 seconds, respectively. The single-precision GPU code on a K40 GPU took 45 seconds for the Tomotherapy dose calculation. Conclusion: We have extended ARCHER, the MIC and GPU-based Monte Carlo dose engine to Tomotherapy and Truebeam dose calculations.

A Practical Approach for Model Checking C/C++11 Code

Writing low-level concurrent software has traditionally required intimate knowledge of the entire toolchain and often has involved coding in assembly. New language standards have extended C and C++ with support for low-level atomic operations and a weak memory model, enabling developers to write portable and efficient multithreaded code. In this article, we present CDSC hecker , a tool for exhaustively exploring the behaviors of concurrent code under the C/C++ memory model. We have used CDSC hecker to exhaustively unit test concurrent data structure implementations and have discovered errors in a published implementation of a work-stealing queue and a single producer, single consumer queue.