Exact-Differential Large-Scale Traffic Simulation

Analyzing large-scale traffics by simulation needs repeating execution many times with various patterns of scenarios or parameters. Such repeating execution brings about big redundancy because the change from a prior scenario to a later scenario is very minor in most cases, for example, blocking only one of roads or changing the speed limit of several roads. In this paper, we propose a new redundancy reduction technique, called exact-differential simulation, which enables to simulate only changing scenarios in later execution while keeping exactly same results as in the case of whole simulation. The paper consists of two main efforts: (i) a key idea and algorithm of the exact-differential simulation, (ii) a method to build large-scale traffic simulation on the top of the exact-differential simulation. In experiments of Tokyo traffic simulation, the exact-differential simulation shows 7.26 times as much elapsed time improvement in average and 2.26 times improvement even in the worst case as the whole simulation

Towards large-scale what-if traffic simulation with exact-differential simulation

To analyze and predict a behavior of large-scale traffics with what-if simulation, it needs to repeat many times with various patterns of what-if scenarios. In this paper, we propose new techniques to efficiently repeat what-if simulation tasks with exact-differential simulation. The paper consists of two main efforts: what-if scenario filtering and exact-differential cloning. The what-if scenario filtering enables to pick up meaningful what-if scenarios and reduces the number of what-if scenarios, which directly decreases total execution time of repeating. The exact-differential cloning enables to execute exact-differential simulation tasks in parallel to improve its total execution time. In our preliminary evaluation in Tokyo bay area's traffic simulation, we show potential of our proposals by estimating how the what-if scenarios filtering reduces the number of meaningless scenarios and also by estimating a performance improvement from our previous works with the exact-differential cloning

BCYCLIC: A parallel block tridiagonal matrix cyclic solver

13 pages, 6 figures.A block tridiagonal matrix is factored with minimal fill-in using a cyclic reduction algorithm that is easily parallelized. Storage of the factored blocks allows the application of the inverse to multiple right-hand sides which may not be known at factorization time. Scalability with the number of block rows is achieved with cyclic reduction, while scalability with the block size is achieved using multithreaded routines (OpenMP, GotoBLAS) for block matrix manipulation. This dual scalability is a noteworthy feature of this new solver, as well as its ability to efficiently handle arbitrary (non-powers-of-2) block row and processor numbers. Comparison with a state-of-the art parallel sparse solver is presented. It is expected that this new solver will allow many physical applications to optimally use the parallel resources on current supercomputers. Example usage of the solver in magneto-hydrodynamic (MHD), three-dimensional equilibrium solvers for high-temperature fusion plasmas is cited.This research has been sponsored by the US Department of Energy under Contract DE-AC05-00OR22725 with UT-Battelle, LLC. This research used resources of the National Center for Computational Sciences at Oak Ridge National Laboratory, which is supported by the Office of Science of the Department of Energy under Contract DE-AC05-00OR22725.Publicad

Simulating heterogeneous behaviours in complex systems on GPUs

Agent Based Modelling (ABM) is an approach for modelling dynamic systems and studying complex and emergent behaviour. ABMs have been widely applied in diverse disciplines including biology, economics, and social sciences. The scalability of ABM simulations is typically limited due to the computationally expensive nature of simulating a large number of individuals. As such, large scale ABM simulations are excellent candidates to apply parallel computing approaches such as Graphics Processing Units (GPUs). In this paper, we present an extension to the FLAME GPU 1 [1] framework which addresses the divergence problem, i.e. the challenge of executing the behaviour of non-homogeneous individuals on vectorised GPU processors. We do this by describing a modelling methodology which exposes inherent parallelism within the model which is exploited by novel additions to the software permitting higher levels of concurrent simulation execution. Moreover, we demonstrate how this extension can be applied to realistic cellular level tissue model by benchmarking the model to demonstrate a measured speedup of over 4x

Silicon enhances suberization and lignification in roots of rice (Oryza sativa)

The beneficial element silicon (Si) may affect radial oxygen loss (ROL) of rice roots depending on suberization of the exodermis and lignification of sclerenchyma. Thus, the effect of Si nutrition on the oxidation power of rice roots, suberization and lignification was examined. In addition, Si-induced alterations of the transcript levels of 265 genes related to suberin and lignin synthesis were studied by custom-made microarray and quantitative Real Time-PCR. Without Si supply, the oxidation zone of 12 cm long adventitious roots extended along the entire root length but with Si supply the oxidation zone was restricted to 5 cm behind the root tip. This pattern coincided with enhanced suberization of the exodermis and lignification of sclerenchyma by Si supply. Suberization of the exodermis started, with and without Si supply, at 4–5 cm and 8–9 cm distance from the root tip (drt), respectively. Si significantly increased transcript abundance of 12 genes, while two genes had a reduced transcript level. A gene coding for a leucine-rich repeat protein exhibited a 25-fold higher transcript level with Si nutrition. Physiological, histochemical, and molecular-biological data showing that Si has an active impact on rice root anatomy and gene transcription is presented here

Applying Reversibility Theory for the Performance Evaluation of Reversible Computations

Reversible computations have been widely studied from the functional point of view and energy consumption. In the literature, several authors have proposed various formalisms (mainly based on process algebras) for assessing the correctness or the equivalence among reversible computations. In this paper we propose the adoption of Markovian stochastic models to assess the quantitative properties of reversible computations. Under some conditions, we show that the notion of time-reversibility for Markov chains can be used to efficiently derive some performance measures of reversible computations. The importance of time-reversibly relies on the fact that, in general, the process’s stationary distribution can be derived efficiently by using numerically stable algorithms. This paper reviews the main results about time-reversible Markov processes and discusses how to apply them to tackle the problem of the quantitative evaluation of reversible computationsReversible computations have been widely studied from the functional point of view and energy consumption. In the literature, several authors have proposed various formalisms (mainly based on process algebras) for assessing the correctness or the equivalence among reversible computations. In this paper we propose the adoption of Markovian stochastic models to assess the quantitative properties of reversible computations. Under some conditions, we show that the notion of time-reversibility for Markov chains can be used to efficiently derive some performance measures of reversible computations. The importance of time-reversibly relies on the fact that, in general, the process's stationary distribution can be derived efficiently by using numerically stable algorithms. This paper reviews the main results about time-reversible Markov processes and discusses how to apply them to tackle the problem of the quantitative evaluation of reversible computations

A Case Study for Reversible Computing: Reversible Debugging of Concurrent Programs

International audienceReversible computing allows one to run programs not only in the usual forward direction, but also backward. A main application area for reversible computing is debugging, where one can use reversibility to go backward from a visible misbehaviour towards the bug causing it. While reversible debugging of sequential systems is well understood, reversible debugging of concurrent and distributed systems is less settled. We present here two approaches for debugging concurrent programs, one based on backtracking, which undoes actions in reverse order of execution, and one based on causal consistency, which allows one to undo any action provided that its consequences, if any, are undone beforehand. The first approach tackles an imperative language with shared memory, while the second one considers a core of the functional message-passing language Erlang. Both the approaches are based on solid formal foundations