Commodity PC Research Articles

Ultrarobust Actuator Comprising High-Strength Carbon Fibers and Commercially Available Polycarbonate with Multi-Stimulus Responses and Programmable Deformation.

Polymer-based actuators have gained extensive attention owing to their potential applications in aerospace, soft robotics, etc. However, poor mechanical properties, the inability of multi-stimuli response and programmable deformation, and the costly fabrication procedure have significantly hindered their practical application. Herein, these issues are overcome via a simple and scalable one-step molding method. The actuator is fabricated by hot-pressing commercial unidirectional carbon fiber/epoxy prepregs with a commodity PC membrane. Notable CTE differences between the CF and PC layers endow the bilayer actuator with fast and reliable actuation deformation. Benefiting from the high strength of CF, the actuator exhibits excellent mechanical performance. Moreover, the anisotropy of CF endows the actuator with design flexibility. Furthermore, the multifunction of CF makes the actuator capable of responding to thermal, optical, and electrical stimulation simultaneously. Based on the bilayer actuator, we successfully fabricated intelligent devices such as light-driven biomimetic flowers, intelligent grippers, and gesture-simulating apparatuses, which further validate the programmability and multi-stimuli response characteristics of this actuator. Strikingly, the prepared gripper possesses a grasping capacity approximately 31.2 times its own weight. It is thus believed that the concept presented paves the way for building next-generation robust robotics.

Algorithms in Tomography and Related Inverse Problems—A Review

In the ever-evolving landscape of tomographic imaging algorithms, this literature review explores a diverse array of themes shaping the field’s progress. It encompasses foundational principles, special innovative approaches, tomographic implementation algorithms, and applications of tomography in medicine, natural sciences, remote sensing, and seismology. This choice is to show off the diversity of tomographic applications and simultaneously the new trends in tomography in recent years. Accordingly, the evaluation of backprojection methods for breast tomographic reconstruction is highlighted. After that, multi-slice fusion takes center stage, promising real-time insights into dynamic processes and advanced diagnosis. Computational efficiency, especially in methods for accelerating tomographic reconstruction algorithms on commodity PC graphics hardware, is also presented. In geophysics, a deep learning-based approach to ground-penetrating radar (GPR) data inversion propels us into the future of geological and environmental sciences. We venture into Earth sciences with global seismic tomography: the inverse problem and beyond, understanding the Earth’s subsurface through advanced inverse problem solutions and pushing boundaries. Lastly, optical coherence tomography is reviewed in basic applications for revealing tiny biological tissue structures. This review presents the main categories of applications of tomography, providing a deep insight into the methods and algorithms that have been developed so far so that the reader who wants to deal with the subject is fully informed.

InTIME: A Machine Learning-Based Framework for Gathering and Leveraging Web Data to Cyber-Threat Intelligence

In today’s world, technology has become deep-rooted and more accessible than ever over a plethora of different devices and platforms, ranging from company servers and commodity PCs to mobile phones and wearables, interconnecting a wide range of stakeholders such as households, organizations and critical infrastructures. The sheer volume and variety of the different operating systems, the device particularities, the various usage domains and the accessibility-ready nature of the platforms creates a vast and complex threat landscape that is difficult to contain. Staying on top of these evolving cyber-threats has become an increasingly difficult task that presently relies heavily on collecting and utilising cyber-threat intelligence before an attack (or at least shortly after, to minimize the damage) and entails the collection, analysis, leveraging and sharing of huge volumes of data. In this work, we put forward inTIME, a machine learning-based integrated framework that provides an holistic view in the cyber-threat intelligence process and allows security analysts to easily identify, collect, analyse, extract, integrate, and share cyber-threat intelligence from a wide variety of online sources including clear/deep/dark web sites, forums and marketplaces, popular social networks, trusted structured sources (e.g., known security databases), or other datastore types (e.g., pastebins). inTIME is a zero-administration, open-source, integrated framework that enables security analysts and security stakeholders to (i) easily deploy a wide variety of data acquisition services (such as focused web crawlers, site scrapers, domain downloaders, social media monitors), (ii) automatically rank the collected content according to its potential to contain useful intelligence, (iii) identify and extract cyber-threat intelligence and security artifacts via automated natural language understanding processes, (iv) leverage the identified intelligence to actionable items by semi-automatic entity disambiguation, linkage and correlation, and (v) manage, share or collaborate on the stored intelligence via open standards and intuitive tools. To the best of our knowledge, this is the first solution in the literature to provide an end-to-end cyber-threat intelligence management platform that is able to support the complete threat lifecycle via an integrated, simple-to-use, yet extensible framework.

Making Procedural Water Waves Boundary‐aware

AbstractThe “procedural” approach to animating ocean waves is the dominant algorithm for animating larger bodies of water in interactive applications as well as in off‐line productions — it provides high visual quality with a low computational demand. In this paper, we widen the applicability of procedural water wave animation with an extension that guarantees the satisfaction of boundary conditions imposed by terrain while still approximating physical wave behavior. In combination with a particle system that models wave breaking, foam, and spray, this allows us to naturally model waves interacting with beaches and rocks. Our system is able to animate waves at large scales at interactive frame rates on a commodity PC.

PacketUsher: Exploiting DPDK to accelerate compute-intensive packet processing

Many compute-intensive network applications such as application-layer traffic generator, Deep Packet Inspection(DPI) and web servers are widely deployed on commodity PC for the reason of flexibility and cheap price. However, how to improve their performance on general purpose OS is challenging due to the high packet I/O related overheads. This paper presents PacketUsher, a high-performance packets processing framework to remove these performance bottlenecks. In building PacketUsher, we constructed a DPDK wrapper as the underlying packet I/O engine to accelerate packet transmission, and utilized the strategies of zero copy, batch processing and parallelism to improve packet processing. Through RFC2544 benchmark, we demonstrate that DPDK wrapper has excellent packets transmission capability. As a case study of PacketUsher, we design and implement a commercial application-layer traffic generator. The experiment results show that the FPS (Flow Per Second) value of our traffic generator over PacketUsher is more than 4 times of that over standard Linux platform. By comparison, the FPS value over PacketUsher is about 3 times of that over existing methods (Netmap and PF_RING).

Systemizing Interprocedural Static Analysis of Large-scale Systems Code with Graspan

There is more than a decade-long history of using static analysis to find bugs in systems such as Linux. Most of the existing static analyses developed for these systems are simple checkers that find bugs based on pattern matching. Despite the presence of many sophisticated interprocedural analyses, few of them have been employed to improve checkers for systems code due to their complex implementations and poor scalability. In this article, we revisit the scalability problem of interprocedural static analysis from a “Big Data” perspective. That is, we turn sophisticated code analysis into Big Data analytics and leverage novel data processing techniques to solve this traditional programming language problem. We propose Graspan , a disk-based parallel graph system that uses an edge-pair centric computation model to compute dynamic transitive closures on very large program graphs. We develop two backends for Graspan, namely, Graspan-C running on CPUs and Graspan-G on GPUs, and present their designs in the article. Graspan-C can analyze large-scale systems code on any commodity PC, while, if GPUs are available, Graspan-G can be readily used to achieve orders of magnitude speedup by harnessing a GPU’s massive parallelism. We have implemented fully context-sensitive pointer/alias and dataflow analyses on Graspan. An evaluation of these analyses on large codebases written in multiple languages such as Linux and Apache Hadoop demonstrates that their Graspan implementations are language-independent, scale to millions of lines of code, and are much simpler than their original implementations. Moreover, we show that these analyses can be used to uncover many real-world bugs in large-scale systems code.

Interactive spatio-temporal exploration of massive time-Varying rectilinear scalar volumes based on a variable bit-rate sparse representation over learned dictionaries

We introduce a novel approach for supporting fully interactive non-linear spatio-temporal exploration of massive time-varying rectilinear scalar volumes on commodity platforms. To do this, we decompose each frame into an octree of overlapping bricks. Each brick is further subdivided into smaller non-overlapping blocks compactly approximated by quantized variable-length sparse linear combinations of prototype blocks stored in a learned data-dependent dictionary. An efficient tolerance-driven learning and approximation process, capable of computing the tolerance required to achieve a given frame size, exploits coresets and an incremental dictionary refinement strategy to cope with datasets made of thousands of multi-gigavoxel frames. The compressed representation of each frame is stored in a GPU-friendly format that supports direct adaptive streaming to the GPU with spatial and temporal random access, view-frustum and transfer-function culling, and transient and local decompression interleaved with ray-casting. Our variable-rate codec provides high-quality approximations at very low bit-rates, while offering real-time decoding performance. Thus, the bandwidth provided by current commodity PCs proves sufficient to fully stream and render a working set of one gigavoxel per frame without relying on partial updates, thus avoiding any unwanted dynamic effects introduced by current incremental loading approaches. The quality and performance of our approach is demonstrated on massive time-varying datasets at the terascale.

Priority Based Classical Data Encapsulated Scheduling For New Era in Computing Environment

In computational environment the data processing and data transactions are major issue, to overcome this problem of processing and reduce the band width in distributed models. The abstract mentioned here clearly state the novelty of the work regarding to data processing and data utilization. This paper shows that the data provided between nodes that are involved in clusters and that is useful to the data utilization schematic in all kinds of clusters. The proposed approach arranges data into data tables and distributes them transversely nodes in a cluster. It recommends jobs to be processed by the cluster then transfers packaged and encapsulated data into nodes to process the data in parallel. This technique employs an incremental data scheduled computation way that keep away from the costly enumeration of data pattern matching necessary by cluster methods. It improves the data locality by forwarding data to the job supporting cluster. This abstraction is enthused by the data processing and data reduce primitives presented in the various job processing environment and many other functional applications used in data grid, data intensive approaches. The Architectural interface is provided in between clusters and is used to achieve high performance on large clusters of commodity PCs. This approach reduces the data request and its processing when it is signed into data clusters. The proposed approach arranges data into data tables and distributes them across nodes in a cluster. It recommend jobs to be processed by the cluster then transfers packaged and encapsulated data into nodes to progression the data in parallel. It improves the data locality by forwarding data to the job supporting cluster. The proposed approach in this paper is helpful where number of nodes involve in cluster is always increasing due to the high end computations that are involved in distributed environment.

Packet Fan-Out Extension for the <monospace>pcap</monospace> Library

The large availability of multi–gigabit network cards for commodity PCs requires network applications to potentially cope with high volumes of traffic. However, computation intensive operations may not catch up with high traffic rates and need to be run in parallel over multiple processing cores. As of today, the vast majority of network applications—e.g., monitoring and IDS systems—are still based on the pcap library interface which, unfortunately, does not provide the native multi–core support, even though the current underlying capture technologies do. This paper introduces a novel version of the pcap library for the Linux operating system that enables transparent application level parallelism. The new library supports fan–out operations for both multi–threaded and multi–process applications, by means of extended API as well as by a declarative grammar for configuration files, suitable for legacy applications. In addition, the library can transparently run on top of the standard Linux socket as well as on other accelerated active engines. Performance evaluation has been carried out on a multi–core architecture in pure capture tests and in more realistic use cases involving monitoring applications such as Tstat and Bro , with standard Linux socket as well as PF_RING and PFQ accelerated engines.

The out-of-core KNN awakens: the light side of computation force on large datasets

K-nearest neighbors (KNN) is a crucial tool for many applications, e.g. recommender systems, image classification and web-related applications. However, KNN is a resource greedy operation particularly for large datasets. We focus on the challenge of KNN computation over large datasets on a single commodity PC with limited memory. We propose a novel approach to compute KNN on large datasets by leveraging both disk and main memory efficiently. The main rationale of our approach is to minimize random accesses to disk, maximize sequential accesses to data and efficient usage of only the available memory. We evaluate our approach on large datasets, in terms of performance and memory consumption. The evaluation shows that our approach requires only 7% of the time needed by an in-memory baseline to compute a KNN graph.

A Fast and Robust Extrinsic Calibration for RGB-D Camera Networks.

From object tracking to 3D reconstruction, RGB-Depth (RGB-D) camera networks play an increasingly important role in many vision and graphics applications. Practical applications often use sparsely-placed cameras to maximize visibility, while using as few cameras as possible to minimize cost. In general, it is challenging to calibrate sparse camera networks due to the lack of shared scene features across different camera views. In this paper, we propose a novel algorithm that can accurately and rapidly calibrate the geometric relationships across an arbitrary number of RGB-D cameras on a network. Our work has a number of novel features. First, to cope with the wide separation between different cameras, we establish view correspondences by using a spherical calibration object. We show that this approach outperforms other techniques based on planar calibration objects. Second, instead of modeling camera extrinsic calibration using rigid transformation, which is optimal only for pinhole cameras, we systematically test different view transformation functions including rigid transformation, polynomial transformation and manifold regression to determine the most robust mapping that generalizes well to unseen data. Third, we reformulate the celebrated bundle adjustment procedure to minimize the global 3D reprojection error so as to fine-tune the initial estimates. Finally, our scalable client-server architecture is computationally efficient: the calibration of a five-camera system, including data capture, can be done in minutes using only commodity PCs. Our proposed framework is compared with other state-of-the-arts systems using both quantitative measurements and visual alignment results of the merged point clouds.

GraphD: Distributed Vertex-Centric Graph Processing Beyond the Memory Limit

We propose GraphD, an out-of-core Pregel-like system targeting efficient big graph processing with a small cluster of commodity PCs connected by Gigabit Ethernet, an environment affordable to most users. This is in contrast to some recent efforts for out-of-core graph computation with specialized hardware. In our setting, a vertex-centric program is often data-intensive, since the CPU cost of calculating a message value is negligible compared with the network cost of transmitting that message. As a result, network bandwidth is usually the bottleneck, and out-of-core execution would not sacrifice performance if disk IO overhead can be hidden by message transmission, which is achieved by GraphD through the parallelism of computation and communication. GraphD streams edge and message data on local disks, and thus consumes negligible memory space. For a broad class of Pregel algorithms where message combiner is applicable, GraphD completely eliminates the need of any expensive external-memory join or group-by, which is required by existing systems such as Pregelix and Chaos. Extensive experiments show that GraphD beats existing out-of-core systems by orders of magnitude, and achieves comparable performance to in-memory systems running with adequate memory.

FOG: A Fast Out-of-Core Graph Processing Framework

In this paper we present FOG, an open source graph processing framework designed for out-of-core (external memory) graph processing (https://github.com/mrshawcode/fog). FOG provides a set of programming interfaces that break down update functions of vertices to their incident edges so as to process the functions with edge-centric manner. By these, FOG gives intuitive and productive programming interfaces, and achieves high main memory utilization rate and processing efficiency at the same time. Moreover, FOG proposes an in-place update shuffling mechanism to improve the performance by dramatically reducing disk I/Os during computing. By extensive evaluations on typical graph algorithms and large real-world graphs, we show that FOG outperforms existing out-of-core graph processing systems, including GraphChi, X-Stream and TurboGraph. By comparing the performances of FOG and those of state-of-art distributed graph processing frameworks, we show that only by using just a commodity PC, FOG achieves comparable or even better performance than the best distributed graph processing framework that uses an Amazon EC2 cluster with 128 nodes.

VENUS: A System for Streamlined Graph Computation on a Single PC

Recent studies show that disk-based graph computation systems on just a single PC can be as highly competitive as cluster-based systems on large-scale problems. Inspired by this remarkable progress, we develop VENUS, a disk-based graph computation system which is able to handle billion-scale graphs efficiently on a commodity PC. VENUS adopts a novel computing architecture that features vertex-centric “streamlined” processing—the graph is sequentially loaded and an update function is executed for each vertex in parallel on the fly. VENUS deliberately avoids loading batch edge data by separating read-only structure data from mutable vertex data on disk, and minimizes random IOs by caching vertex data in the main memory whenever possible. The streamlined processing is realized with efficient sequential scan over massive structure data and fast feeding the update function for a large number of vertices. Extensive evaluation on large real-world and synthetic graphs has demonstrated the efficiency of VENUS. For example, to run the PageRank algorithm on a Twitter graph of 42 million vertices and 1.4 billion edges, Spark needs 8.1 minutes with 50 machines and GraphChi spends 13 minutes using high-speed SSD, while VENUS only takes 5 minutes on one machine with an ordinary hard disk.

Mega-KV

In-memory key-value stores play a critical role in data processing to provide high throughput and low latency data accesses. In-memory key-value stores have several unique properties that include (1) data intensive operations demanding high memory bandwidth for fast data accesses, (2) high data parallelism and simple computing operations demanding many slim parallel computing units, and (3) a large working set. As data volume continues to increase, our experiments show that conventional and general-purpose multicore systems are increasingly mismatched to the special properties of key-value stores because they do not provide massive data parallelism and high memory bandwidth; the powerful but the limited number of computing cores do not satisfy the demand of the unique data processing task; and the cache hierarchy may not well benefit to the large working set. In this paper, we make a strong case for GPUs to serve as special-purpose devices to greatly accelerate the operations of in-memory key-value stores. Specifically, we present the design and implementation of Mega-KV, a GPU-based in-memory key-value store system that achieves high performance and high throughput. Effectively utilizing the high memory bandwidth and latency hiding capability of GPUs, Mega-KV provides fast data accesses and significantly boosts overall performance. Running on a commodity PC installed with two CPUs and two GPUs, Mega-KV can process up to 160+ million key-value operations per second, which is 1.4-2.8 times as fast as the state-of-the-art key-value store system on a conventional CPU-based platform.

Parallel community detection on large graphs with MapReduce and GraphChi

Community detection from social network data gains much attention from academia and industry since it has many real-world applications. The Girvan–Newman (GN) algorithm is a divisive hierarchical clustering algorithm for community detection, which is regarded as one of the most popular algorithms. It exploits the concept of edge betweenness to divide a network into multiple communities. Though it is being widely used, it has limitations in supporting large-scale networks since it needs to calculate the shortest path between every pair of vertices in a network. In this paper, we develop two parallel versions of the GN algorithm to support large-scale networks. First, we propose a new algorithm, which we call Shortest Path Betweenness MapReduce Algorithm (SPB-MRA), that utilizes the MapReduce model. Second, we propose another new algorithm, which we call Shortest Path Betweenness Vertex-Centric Algorithm (SPB-VCA), that utilizes the vertex-centric model. An approximation technique is also developed to further speed up community detection processes. We implemented SPB-MRA using Hadoop and SPB-VCA using GraphChi, and then evaluated the performance of SPB-MRA on Amazon EC2 instances and that of SPB-VCA on a single commodity PC. The evaluation results showed that the elapsed time of SPB-MRA decreased almost linearly as the number of reducers increased, SPB-VCA outperformed SPB-MRA just on a single PC by 4–6 times, and the approximation technique introduced negligible errors.

Adaptive image contrast enhancement algorithm for point-based rendering

Surgical simulation is a major application in computer graphics and virtual reality, and most of the existing work indicates that interactive real-time cutting simulation of soft tissue is a fundamental but challenging research problem in virtual surgery simulation systems. More specifically, it is difficult to achieve a fast enough graphic update rate (at least 30 Hz) on commodity PC hardware by utilizing traditional triangle-based rendering algorithms. In recent years, point-based rendering (PBR) has been shown to offer the potential to outperform the traditional triangle-based rendering in speed when it is applied to highly complex soft tissue cutting models. Nevertheless, the PBR algorithms are still limited in visual quality due to inherent contrast distortion. We propose an adaptive image contrast enhancement algorithm as a postprocessing module for PBR, providing high visual rendering quality as well as acceptable rendering efficiency. Our approach is based on a perceptible image quality technique with automatic parameter selection, resulting in a visual quality comparable to existing conven- tional PBR algorithms. Experimental results show that our adaptive image contrast enhancement algorithm produces encouraging results both visually and numerically compared to representative algorithms, and experi- ments conducted on the latest hardware demonstrate that the proposed PBR framework with the postprocessing module is superior to the conventional PBR algorithm and that the proposed contrast enhancement algorithm can be utilized in (or compatible with) various variants of the conventional PBR algorithm. © 2015 SPIE and IS&T (DOI: 10.1117/1.JEI.24.2.023033)

Data-flow Performance Optimisation on Unreliable Networks: the ATLAS Data-Acquisition Case

The ATLAS detector at CERN records proton-proton collisions delivered by the Large Hadron Collider (LHC). The ATLAS Trigger and Data-Acquisition (TDAQ) system identifies, selects, and stores interesting collision data. These are received from the detector readout electronics at an average rate of 100 kHz. The typical event data size is 1 to 2 MB. Overall, the ATLAS TDAQ system can be seen as a distributed software system executed on a farm of roughly 2000 commodity PCs. The worker nodes are interconnected by an Ethernet network that at the restart of the LHC in 2015 is expected to experience a sustained throughput of several 10 GB/s.A particular type of challenge posed by this system, and by DAQ systems in general, is the inherently burstynature of the data traffic from the readout buffers to the worker nodes. This can cause instantaneous network congestion and therefore performance degradation. The effect is particularly pronounced for unreliable network interconnections, such as Ethernet.In this paper we report on the design of the data-flow software for the 2015-2018 data-taking period of the ATLAS experiment. This software will be responsible for transporting the data across the distributed Data-Acquisition system. We will focus on the strategies employed to manage the network congestion and therefore minimisethe data-collection latency and maximisethe system performance. We will discuss the results of systematic measurements performed on different types of networking hardware. These results highlight the causes of network congestion and the effects on the overall system performance.

Energy-Oriented Partial Desktop Virtual Machine Migration

Modern offices are crowded with personal computers. While studies have shown these to be idle most of the time, they remain powered, consuming up to 60% of their peak power. Hardware-based solutions engendered by PC vendors (e.g., low-power states, Wake-on-LAN) have proved unsuccessful because, in spite of user inactivity, these machines often need to remain network active in support of background applications that maintain network presence. Recent proposals have advocated the use of consolidation of idle desktop Virtual Machines (VMs). However, desktop VMs are often large, requiring gigabytes of memory. Consolidating such VMs creates large network transfers lasting in the order of minutes and utilizes server memory inefficiently. When multiple VMs migrate concurrently, networks become congested, and the resulting migration latencies are prohibitive. We present partial VM migration, an approach that transparently migrates only the working set of an idle VM. It creates a partial replica of the desktop VM on the consolidation server by copying only VM metadata, and it transfers pages to the server on-demand, as the VM accesses them. This approach places desktop PCs in low-power mode when inactive and switches them to running mode when pages are needed by the VM running on the consolidation server. To ensure that desktops save energy, we have developed sleep scheduling and prefetching algorithms, as well as the context-aware selective resume framework, a novel approach to reduce the latency of power mode transition operations in commodity PCs. Jettison, our software prototype of partial VM migration for off-the-shelf PCs, can deliver 44--91% energy savings during idle periods of at least 10 minutes, while providing low migration latencies of about 4 seconds and migrating minimal state that is under an order of magnitude of the VM’s memory footprint.

An introduction to PYTHIA 8.2

The Pythia program is a standard tool for the generation of events in high-energy collisions, comprising a coherent set of physics models for the evolution from a few-body hard process to a complex multiparticle final state. It contains a library of hard processes, models for initial- and final-state parton showers, matching and merging methods between hard processes and parton showers, multiparton interactions, beam remnants, string fragmentation and particle decays. It also has a set of utilities and several interfaces to external programs. Pythia 8.2 is the second main release after the complete rewrite from Fortran to C++, and now has reached such a maturity that it offers a complete replacement for most applications, notably for LHC physics studies. The many new features should allow an improved description of data. New version program summaryProgram title: Pythia 8.2Catalogue identifier: ACTU_v4_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ACTU_v4_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU General Public Licence, version 2No. of lines in distributed program, including test data, etc.: 478360No. of bytes in distributed program, including test data, etc.: 14131810Distribution format: tar.gzProgramming language: C++.Computer: Commodity PCs, Macs.Operating system: Linux, OS X; should also work on other systems.RAM: ∼10 megabytesClassification: 11.2.Does the new version supersede the previous version?: YesCatalogue identifier of previous version: ACTU_v3_0Journal reference of previous version: Comput. Phys. Comm. 178 (2008) 852Nature of problem: High-energy collisions between elementary particles normally give rise to complex final states, with large multiplicities of hadrons, leptons, photons and neutrinos. The relation between these final states and the underlying physics description is not a simple one, for two main reasons. Firstly, we do not even in principle have a complete understanding of the physics. Secondly, any analytical approach is made intractable by the large multiplicities.Solution method: Complete events are generated by Monte Carlo methods. The complexity is mastered by a subdivision of the full problem into a set of simpler separate tasks. All main aspects of the events are simulated, such as hard-process selection, initial- and final-state radiation, beam remnants, fragmentation, decays, and so on. Therefore events should be directly comparable with experimentally observable ones. The programs can be used to extract physics from comparisons with existing data, or to study physics at future experiments.Reasons for new version: Improved and expanded physics models.Summary of revisions: Hundreds of new features and bug fixes, allowing improved modelling.Restrictions: Depends on the problem studied.Running time: 10–1000 events per second, depending on process studied.