A Framework for Megascale Agent Based Model Simulations on Graphics Processing Units

Agent-based modeling is a technique for modeling dynamic systems from the bottom up. Individual elements of the system are represented computationally as agents. The system-level behaviors emerge from the micro-level interactions of the agents. Contemporary state-of-the-art agent-based modeling toolkits are essentially discrete-event simulators designed to execute serially on the Central Processing Unit (CPU). They simulate Agent-Based Models (ABMs) by executing agent actions one at a time. In addition to imposing an un-natural execution order, these toolkits have limited scalability. In this article, we investigate data-parallel computer architectures such as Graphics Processing Units (GPUs) to simulate large scale ABMs. We have developed a series of efficient, data parallel algorithms for handling environment updates, various agent interactions, agent death and replication, and gathering statistics. We present three fundamental innovations that provide unprecedented scalability. The first is a novel stochastic memory allocator which enables parallel agent replication in O(1) average time. The second is a technique for resolving precedence constraints for agent actions in parallel. The third is a method that uses specialized graphics hardware, to gather and process statistical measures. These techniques have been implemented on a modern day GPU resulting in a substantial performance increase. We believe that our system is the first ever completely GPU based agent simulation framework. Although GPUs are the focus of our current implementations, our techniques can easily be adapted to other data-parallel architectures. We have benchmarked our framework against contemporary toolkits using two popular ABMs, namely, SugarScape and StupidModel.GPGPU, Agent Based Modeling, Data Parallel Algorithms, Stochastic Simulations

DETC2007-34902 REAL TIME MACHINABILITY ANALYSIS OF FREE FORM SURFACES ON THE GPU

In this paper a new hardware accelerated method is presented to evaluate the machinability of free-form surfaces. This method works on tessellated models that are commonly used by CAD systems to render three-dimensional shaded images of solid models. Modern Graphics Processing Units (GPUs) can be programmed in hardware to accelerate specialized rendering techniques. In this research, we have developed new algorithms that utilize the programmability of GPUs to evaluate machinability of free-form surfaces. The method runs in real time on fairly inexpensive hardware (<$600), and performs well regardless of the surface type. The complexity of the method is dictated by the size of the projected view of the model. The proposed method can be used as a plug-in in a CAD system to evaluate manufacturability of a part at early design stages. The efficiency and the speed of the proposed method are demonstrated on some complex objects. 1

Real time machinability analysis of free form surfaces on the GPU

In this paper a new hardware accelerated method is presented to evaluate the machinability of free-form surfaces. This method works on tessellated models that are commonly used by CAD systems to render three-dimensional shaded images of solid models. Modern Graphics Processing Units (GPUs) can be programmed in hardware to accelerate specialized rendering techniques. In this research, we have developed new algorithms that utilize the programmability of GPUs to evaluate machinability of free-form surfaces. The method runs in real time on fairly inexpensive hardware ( \u3c $600), and performs well regardless of the surface type. The complexity of the method is dictated by the size of the projected view of the model. The proposed method can be used as a plug-in in a CAD system to evaluate manufacturability of a part at early design stages. The efficiency and the speed of the proposed method are demonstrated on some complex objects. Copyright © 2007 by ASME

Improved Binary Space Partition merging

This paper presents a new method for evaluating boolean set operations between Binary Space Partition (BSP) trees. Our algorithm has many desirable features, including both numerical robustness and O (n) output sensitive time complexity, while simultaneously admitting a straightforward implementation. To achieve these properties, we present two key algorithmic improvements. The first is a method for eliminating null regions within a BSP tree using linear programming. This replaces previous techniques based on polygon cutting and tree splitting. The second is an improved method for compressing BSP trees based on a similar approach within binary decision diagrams. The performance of the new method is analyzed both theoretically and experimentally. Given the importance of boolean set operations, our algorithms can be directly applied to many problems in graphics, CAD and computational geometry. © 2008 Elsevier Ltd. All rights reserved

Path-Based Mathematical Morphology on Tensor Fields

Traditional path-based morphology allows finding long, approximately straight, paths in images. Although originally applied only to scalarimages, we show how this can be a very good fit for tensor fields. We do thisby constructing directed graphs representing such data, and then modifyingthe traditional path opening algorithm to work on these graphs. Cycles aredealt with by finding strongly connected components in the graph. Some examples of potential applications are given, including path openings that arenot limited to a specific set of orientations.<br/

A Framework for Megascale Agent Based Simulations on the GPU

This paper presents a series of efficient, data parallel algorithms for simulating agent based models on a graphics processing unit (GPU). These include methods for handling environment updates, agent interactions, and replication. One of the most important techniques presented in this work is a novel stochastic allocator which enables parallel agent replication in O(1) average time. We believe that our system is the first ever completely GPU based agent simulation framework. Due to a combination of algorithmic and architectural advancements, our prototype system achieves a speed up of several orders of magnitude over conventional CPU based approaches

A Framework for Megascale Agent Based Model Simulations on the GPU

This paper presents a series of efficient, data parallel algorithms for simulating agent based models. These include methods for handling environment updates, agent interactions and replication. One of the most important techniques presented in this work is a novel stochastic allocator which enables parallel agent replication in O(1) average time. These techniques can be easily implemented on a modern day graphics processing unit (GPU) resulting in a substantial performance increase. We believe that our system is the first ever completely GPU based agent simulation framework

Data-parallel techniques for agent-based tissue modeling on graphics processing units

Agent-Based Modeling has been recently recognized as a method for in-silico multi-scale modeling of biological cell systems. Agent-Based Models (ABMs) allow results from experimental studies of individual cell behaviors to be scaled into the macro-behavior of interacting cells in complex cell systems or tissues. Current generation ABM simulation toolkits are designed to work on serial von-Neumann architectures, which have poor scalability. The best systems can barely handle tens of thousands of agents in real-time. Considering that there are models for which mega-scale populations have significantly different emergent behaviors than smaller population sizes, it is important to have the ability to model such large scale models in real-time. In this paper we present a new framework for simulating ABMs on programmable graphics processing units (GPUs). Novel algorithms and data-structures have been developed for agent-state representation, agent motion, and replication. As a test case, we have implemented an abstracted version of the Systematic Inflammatory Response System (SIRS) ABM. Compared to the original implementation on the NetLogo system, our implementation can handle an agent population that is over three orders of magnitude larger with close to 40 updates/sec. We believe that our system is the only one of its kind that is capable of efficiently handling realistic problem sizes in biological simulations. Copyright © 2008 by ASME