Gradient-based optimization methods are commonly used to identify local optima in high-dimensional spaces. When derivatives cannot be evaluated directly, stochastic estimators can provide approximate gradients. However, these estimators’ perturbation-based sampling of the objective function introduces variance that can lead to slow convergence. In this paper, we present dimensional peeking, a variance reduction method for gradient estimation in discrete optimization via simulation. By lifting the sampling granularity from scalar values to classes of values that follow the same control flow path, we increase the information gathered per simulation evaluation. Our derivation from an established smoothed gradient estimator shows that the method does not introduce any bias. We present an implementation via a custom numerical data type to transparently carry out dimensional peeking over C++ programs. Variance reductions by factors of up to 7.9 are observed for three simulation-based optimization problems with high-dimensional input. The optimization progress compared to three meta-heuristics shows that dimensional peeking increases the competitiveness of zeroth-order optimization for discrete and non-convex simulations.

Content delivery in vehicular edge networks faces critical challenges due to dynamic user mobility, unpredictable content request patterns, and limited storage at edge nodes. To tackle these problems, we propose a distributed online framework that jointly performs proactive caching at roadside units (RSUs) and hierarchical prefetching from the cloud to macro base stations (MBSs), enabling real-time adaptation to spatiotemporal variations in content demand across different time scales. Our goal is to minimize content transmission latency while satisfying system-wide resource and cost constraints. The proposed Vehicular-based Online Proactive caching and Prefetching (VOPP), integrates trajectory-based user mobility prediction with future content demand estimation to guide online distributed caching. At the RSU level, we formulate a distributed online convex optimization model with fine-grained gradient updates and inter-agent coordination based on real-time mobility patterns. At the MBS level, we construct a multi-step predicted content set using user mobility and request forecasts, and define a value density metric that combines popularity and delay reduction. On both levels, additional subsequent refinement steps ensure high-quality caching decisions. Extensive simulations based on a real-world GPS dataset of 10,357 taxi trajectories in Beijing demonstrate that VOPP significantly reduces transmission delay and achieves robust performance across diverse mobility patterns and user densities, outperforming baseline methods.

Monte Carlo gradient estimators enable an efficient gradient-driven local search in a simulation’s parameter space. Partial derivatives are estimated based on the simulation outputs at random perturbations around the current parameter combination. However, the effective computational cost grows with the number of perturbations. Here, we explore the use of modern CPUs’ vector instructions to reduce the estimation time on a single processor core. We vectorize across simulation trajectories, based on the hypothesis that the perturbations can be chosen small enough that the control flow divergence remains low. Control flow is realized using a predication scheme, allowing model code to remain similar to its scalar counterpart. Since the approach trivially benefits numerical simulations without parameter-dependent control flow, our evaluation instead considers the calibration of a building evacuation model in which transitive effects of perturbations change the neighborhood relation among pedestrians. Our cross-trajectory vectorization scheme speeds up the model’s calibration via simulation-based inference by a factor of about 1.5 without occupying additional cores.

Heterogeneous hardware platforms comprised of CPUs, GPUs, and other accelerators offer the opportunity to choose the best-suited device for executing a given scientific simulation in order to minimize execution time and energy consumption. To this end, the recently proposed "Follow the Leader" approach dynamically selects a suitable device based on runtime performance measurements during speculative discrete-event simulations. A currently active "leader" device is periodically challenged by a "follower" device in order to negotiate the new leader. The optimality of the device choices and the associated overhead depends critically on the challenge frequency and timing. Here, we explore policies to schedule challenges with the goal of attaining Pareto-optimal combinations of execution time and energy consumption. Several heuristics are first evaluated in an abstract fashion using a "meta-simulation" by mimicking the progress and energy consumption of an idealized co-execution. In this setting, we optimize the heuristics’ tuning parameters to assess their relative merits in near-optimal configurations when compared to challenge timings based on perfect knowledge. We find that under challenging stochastic workloads based on a class of mean-reverting random walks, the best heuristics can closely approximate the execution time and energy consumption achievable under an optimal device choice. Empirical support for this observation is given by measurements of a CPU/GPU co-execution of the Time Warp algorithm on physical hardware.

Increasing effort is put into the development of methods for learning mechanistic models from data. This task entails not only the accurate estimation of parameters but also a suitable model structure. Recent work on the discovery of dynamical systems formulates this problem as a linear equation system. Here, we explore several simulation-based optimization approaches, which allow much greater freedom in the objective formulation and weaker conditions on the available data. We show that even for relatively small stochastic population models, simultaneous estimation of parameters and structure poses major challenges for optimization procedures. Particularly, we investigate the application of the local stochastic gradient descent method, commonly used for training machine learning models. We demonstrate accurate estimation of models but find that enforcing the inference of parsimonious, interpretable models drastically increases the difficulty. We give an outlook on how this challenge can be overcome.

Despite the successes of graphics processing units (GPUs) in accelerating simulations in several research fields, their use is largely restricted to domain-specific workloads that consistently offer the large degree of inherent parallelism and computational intensity at which GPUs excel. When targeting generic discrete-event simulations, whose dynamics can vary wildly over time, a static choice between a GPU-based and traditional CPU-based execution is likely to be suboptimal. Here, we explore a parallel discrete-event (PDES) execution scheme for CPU-GPU platforms that aims to approximate an optimal dynamic device choice. Starting from an intermediate model state, a current “leader” device running the simulation is periodically challenged by a brief concurrent run on another device starting from an intermediate model state. Based on the gathered performance measurements, a forecasting scheme determines the leader for the next period. The execution time and power consumption of this scheme hinge on 1) an efficient mechanism for providing the “follower” device with a consistent model state, and 2) robust performance forecasting to justify the device choices. We present these building blocks, their implementation combining the existing CPU and GPU simulators ROOT-Sim and GPUTW, and measurement results demonstrating substantially reduced execution time without increasing energy consumption over a static device choice.

Synchronization algorithms for parallel simulation struggle to attain speedup if the simulation entities are tightly coupled and their interactions are difficult to predict. Window Racer is a novel parallel synchronization algorithm for shared-memory architectures specifically targeted toward attaining speedup in these challenging cases. The key idea is to speculatively process sequences of dependent events even across partition boundaries through fine-grained locking and low-overhead rollbacks, while negotiating a global synchronization window that rules out transitive rollbacks. In performance measurements using a variant of the PHold benchmark model, Window Racer outperforms an established implementation of the Time Warp algorithm in model configurations where events are often scheduled with near-zero delay. In an ablation study, we pinpoint the performance impact of our algorithm’s individual features by reducing Window Racer to two existing algorithms. We further study the algorithm’s ability to attain speedup in simulations of bio-chemical reaction networks, a particularly challenging class of simulations with tightly coupled state transitions.

Parallel discrete-event simulation (PDES) is a well-established family of methods to accelerate discrete-event simulations. However, the available algorithms vary substantially in the performance achievable for different models, largely preventing generic solutions applicable by modellers without expert knowledge. For instance, in Time Warp, the processing elements execute events asynchronously and speculatively with high aggressiveness, leading to frequent and costly rollbacks if misspeculations occur often. In contrast, synchronous approaches such as the new Window Racer algorithm exhibit a more cautious form of speculation. In the present paper, we combine these two fundamentally different algorithms within a single runtime environment, allowing for a choice of the best algorithm for different model segments. We describe the architecture and the algorithmic considerations to support the efficient coexistence and interaction of the algorithms without violating the correctness of the simulation. Our experiments using a synthetic benchmark and an epidemics model show that the hybrid algorithm is less sensitive to its configuration and can deliver substantially higher performance in models with varying degrees of coupling among entities compared to each algorithm on its own.

Continuous-time agent-based models often represent tightly-coupled systems in which an agent’s state transitions occur in close interaction with neighboring agents. Without artificial discretization, the potential for near-instantaneous propagation of effects across the model presents a challenge to parallelizing their execution. Although existing algorithms can tackle the largely unpredictable nature of such simulations through speculative execution, they are subject to trade-offs concerning the degree of optimism, the probability and cost of rollbacks, and the exploitation of locality. This paper is aimed at understanding the suitability of asynchronous and synchronous parallel simulation algorithms when executing continuous-time agent-based models with rate-driven stochastic transitions. We present extensive measurement results comparing optimized implementations under various configurations of a parametrizable simulation model of the epidemic spread of disease. Our results show that the amount of locality in the agent interactions is the decisive factor for the relative performance of the approaches. Based on profiling results, we identify remaining hurdles for higher simulation performance with the two classes of algorithms and outline potential refinements.

Among the parallel and distributed simulation field’s main subjects are the performance benefits of new methods and optimizations. However, performance evaluations of the various simulators often rely on custom models, parametrizations, and baseline implementations, which complicates direct comparisons. We present our vision and initial steps towards COMPADS, a benchmark model and repository for reproducibly comparing the performance of parallel and distributed simulators and their respective algorithms. COMPADS is short for COMparing Parallel And Distributed Simulators. The first results include a novel deterministic-by-design synthetic benchmark model inspired by PHOLD and La-pdes. The benchmark output is a checksum that attests to the correctness of an implementation and its execution. So far, implementations exist for the simulators ROOT-Sim and ROSS.

Agent-based simulations relying on synchronous state updates using a fixed time step size are considered attractive candidates for parallel execution in order to reduce simulation running times for large and complex scenarios. However, if the underlying models are formulated with respect to continuous time, a time-stepped execution may only approximate the strict model semantics. To simulate continuous-time agent-based models, parallel discrete event algorithms can be applied. Traditionally those are based on logical processes exchanging time-stamped events, which clashes with the properties of models in which tightly coupled agents frequently access each other's states. To illustrate the challenges of such models and to derive a solution, we consider the domain-specific modeling language ML3, which allows modelers to succinctly express transitions and interactions of linked agents based on a continuous-time Markov chain (CTMC) semantics. We propose an optimistic synchronization scheme tailored towards simulations of fine-grained interactions among tightly coupled agents in highly dynamic topologies. By restricting the progress per round to at most one state change per agent, the synchronization scheme enables efficient direct read and write accesses among agents. To maintain concurrency given actions that depend on dynamically updated macro-level properties, we introduce a simple relaxation scheme with guaranteed error bounds. Using an extended variant of the classical susceptible-infected-recovered network model, we demonstrate that the proposed synchronization scheme accelerates simulations even under challenging model configurations.

Simulation-based optimization using agent-based models is typically carried out under the assumption that the gradient describing the sensitivity of the simulation output to the input cannot be evaluated directly. To still apply gradient-based optimization methods, which efficiently steer the optimization towards a local optimum, gradient estimation methods can be employed. However, many simulation runs are needed to obtain accurate estimates if the input dimension is large. Automatic differentiation (AD) is a family of techniques to compute gradients of general programs directly. Here, we explore the use of AD in the context of time-driven agent-based simulations. By substituting common discrete model elements such as conditional branching with smooth approximations, we obtain gradient information across discontinuities in the model logic. On the example of microscopic traffic models and an epidemics model, we study the fidelity and overhead of the differentiable models, as well as the convergence speed and solution quality achieved by gradient-based optimization compared to gradient-free methods. In traffic signal timing optimization problems with high input dimension, the gradient-based methods exhibit substantially superior performance. Finally, we demonstrate that the approach enables gradient-based training of neural network-controlled simulation entities embedded in the model logic.

In an agent-based simulation (ABS), a state update scheme carries out the transitions of agents from one state to the next. To produce correct simulation results, the update scheme must respect the cause-and-effect relationships defined by the agent-based model and ensure that the resulting overall simulation state is internally consistent. At the same time, the update scheme should be efficient enough to meet a simulationist's demand for timely results. Considering the common class of synchronous time-driven ABS, a number of update schemes have been employed in the literature and simulation frameworks. In this paper, various implementations of update schemes are analyzed and contrasted with respect to their ability to maintain the simulation correctness as well as their performance characteristics. A semantic model is formulated to define the reference behavior of synchronous time-driven ABS updates and model the dependencies among agent updates using a state access graph. Relying on the formalization, conditions under which different update schemes achieve causality are shown. Further, resolution methods are categorized according to their coordination mechanisms to achieve consistency by resolving conflicts among agent state updates. Through two case studies, the empirical performance of different update schemes and resolution methods are evaluated. For sequential execution, an update scheme based on the agent's dependencies achieves the highest performance, whereas in the parallel case, the choice of update scheme involves a tradeoff between execution time and memory usage. If deterministic simulation output is required, decentralized coordination generally outperforms centralized coordination. The results can assist implementers and researchers in their selection of appropriate methods in the design and implementation of agent-based simulators.

State fast-forwarding has been proposed as a method to reduce the computational cost of microscopic traffic simulations while retaining per-vehicle trajectories. However, since fast-forwarding relies on vehicles isolated on the road, its benefits extend only to situations of sparse traffic. In this paper, we propose fast-forwarding of vehicle clusters by training artificial neural networks to capture the interactions between vehicles across multiple simulation time steps. We explore various configurations of neural networks in light of the trade-off between accuracy and performance. Measurements in road network simulations demonstrate that cluster fast-forwarding can substantially outperform both time-driven state updates and single-vehicle fast-forwarding, while introducing only a small deviation in travel times.

The performance of Agent-based Traffic Simulations (ABTS) has been shown to benefit tremendously from offloading to accelerators such as GPUs. In the search for the most suitable hardware platform, reconfigurable hardware is a natural choice. Some recent work considered ABTS on Field-Programmable Gate Arrays (FPGAs), yet only implemented simplified cellular automaton-based models. The recent introduction of support for high-level synthesis from C, C++, and OpenCL in FPGA tool chains allows FPGA designs to be expressed in a form familiar to software developers. However, the performance achievable with this approach in a simulation context is not well-understood. In this work, to the best of our knowledge, we present the first FPGA-accelerated ABTS based on widely-accepted microscopic traffic simulation models, and the first to be generated from high-level code. The achieved speedup of up to 24.3 over a sequential CPU-based execution indicates that recent FPGA toolchains allow simulationists to unlock the performance benefits of reconfigurable hardware without the need to express the simulation models in low-level hardware description languages.

Summary The execution of agent‐based simulations (ABSs) on hardware accelerator devices such as graphics processing units (GPUs) has been shown to offer great performance potentials. However, in heterogeneous hardware environments, it can become increasingly difficult to find viable partitions of the simulation and provide implementations for different hardware devices. To automate this process, we present OpenABLext, an extension to OpenABL, a model specification language for ABSs. By providing a device‐aware OpenCL backend, OpenABLext enables the co‐execution of ABS on heterogeneous hardware platforms consisting of central processing units, GPUs, and field programmable gate arrays (FPGAs). We present a novel online dispatching method that efficiently profiles partitions of the simulation during run‐time to optimize the hardware assignment while using the profiling results to advance the simulation itself. In addition, OpenABLext features automated conflict resolution based on user‐specified rules, supports graph‐based simulation spaces, and utilizes an efficient neighbor search algorithm. We show the improved performance of OpenABLext and demonstrate the potential of FPGAs in the context of ABS. We illustrate how co‐execution can be used to further lower execution times. OpenABLext can be seen as an enabler to tap the computing power of heterogeneous hardware platforms for ABS.

We propose an approach for reverse-in-time exploration of the state space of microscopic traffic simulations starting from a user-specified class of outcomes. As a basis for our approach, we present a reversible execution scheme applicable to common car-following and lane-changing models from the traffic simulation literature. The execution scheme permits perfect reversal of a previous forward simulation, which to our knowledge has not been attempted previously in the context of established traffic simulation models. Further, we perform reverse state space explorations directly from user-specified simulation states, i.e., reverse-in-time model checking. By exploring all sequences of possible previous states from a final state, reachability questions can be answered more conclusively than purely through forward simulations. In a case study, reverse exploration is used to identify conditions that lead to specified accident situations, with running time reductions by factors of more than 20 compared to traditional forward exploration.

Spiking neural networks (SNN) are among the most computationally intensive types of simulation models, with node counts on the order of up to 10^11. Currently, there is intensive research into hardware platforms suitable to support large-scale SNN simulations, whereas several of the most widely used simulators still rely purely on the execution on CPUs. Enabling the execution of these established simulators on heterogeneous hardware allows new studies to exploit the many-core hardware prevalent in modern supercomputing environments, while still being able to reproduce and compare with results from a vast body of existing literature. In this paper, we propose a transition approach for CPU-based SNN simulators to enable the execution on heterogeneous hardware (e.g., CPUs, GPUs, and FPGAs) with only limited modifications to an existing simulator code base, and without changes to model code. Our approach relies on manual porting of a small number of core simulator functionalities as found in common SNN simulators, whereas unmodified model code is analyzed and transformed automatically. We apply our approach to the well-known simulator NEST and make a version executable on heterogeneous hardware available to the community. Our measurements show that at full utilization, a single GPU achieves the performance of about 9 CPU cores.

Microscopic traffic simulation is associated with substantial runtimes, limiting the feasibility of large-scale evaluation of traffic scenarios. Even though today heterogeneous hardware comprised of CPUs, graphics processing units (GPUs) and fused CPU-GPU devices is inexpensive and widely available, common traffic simulators still rely purely on CPU-based execution, leaving substantial acceleration potentials untapped. A number of existing works have considered the execution of traffic simulations on accelerators, but have relied on simplified models of road networks and driver behaviour tailored to the given hardware platform. Thus, the existing approaches cannot directly benefit from the vast body of research on the validity of common traffic simulation models. In this paper, we explore the performance gains achievable through the use of heterogeneous hardware when relying on typical traffic simulation models used in CPU-based simulators. We propose a partial offloading approach that relies either on a dedicated GPU or a fused CPU-GPU device. Further, we present a traffic simulation running fully on a manycore GPU and discuss the challenges of this approach. Our results show that a CPU-based parallelisation closely approaches the results of partial offloading, while full offloading substantially outperforms the other approaches. We achieve a speedup of up to 28.7× over the sequential execution on a CPU.

Traditionally, the model time in agent-based simulations is advanced in fixed time steps. However, a purely time-stepped execution is inefficient in situations where the states of individual agents are independent of other agents and thus easily predictable far into the simulated future. In this work, we propose a method to accelerate microscopic traffic simulations based on identifying independence among agent state updates. Instead of iteratively updating an agent's state throughout a sequence of time steps, a computationally inexpensive "fast-forward" function advances the agent's state to the time of its earliest possible interaction with other agents. To demonstrate the approach in practice, we present an algorithm to efficiently determine intervals of independence in microscopic traffic simulations and derive a fast-forward function for the popular Intelligent Driver Model (IDM). In contrast to existing acceleration approaches based on reducing the level of model detail, our approach retains the microscopic nature of the simulation. A performance evaluation is performed in a synthetic scenario and on the road network of the city of Singapore. At low traffic densities, we achieved a speedup of up to 2.8, whereas at the highest considered densities, only few opportunities for fast-forwarding could be identified. The algorithm parameters can be tuned to control the overhead of the approach.

Graphics processing units (GPUs) have been shown to be well-suited to accelerate agent-based simulations. A fundamental challenge in agent-based simulations is the resolution of conflicts arising when agents compete for simulated resources, which may introduce substantial overhead. A variety of conflict resolution methods on the GPU have been proposed in the literature. In this paper, we systematize and compare these methods and propose two simple new variants. We present performance measurements on the example of the well-known segregation model. We show that the choice of conflict resolution method can substantially affect the simulation performance. Further, although methods in which agents actively indicate their interest in a resource require the use of costly atomic operations, these methods generally outperform the alternatives.

Graphics processing units (GPUs) are increasingly applied to accelerate tasks such as graph problems and discreteevent simulation that are characterized by irregularity, i.e., a strong dependence of the control flow and memory accesses on the input. The core data structure in many of these irregular tasks are priority queues that guide the progress of the computations and which can easily become the bottleneck of an application. To our knowledge, currently no systematic comparison of priority queue implementations on GPUs exists in the literature. We close this gap by a performance evaluation of GPU-based priority queue implementations for two applications: discrete-event simulation and parallel A* path searches on grids. We focus on scenarios requiring large numbers of priority queues holding up to a few thousand items each. We present performance measurements covering linear queue designs, implicit binary heaps, splay trees, and a GPU-specific proposal from the literature. The measurement results show that up to about 500 items per queue, circular buffers frequently outperform tree-based queues for the considered applications, particularly under a simple parallelization of individual item enqueue operations. We analyze profiling metrics to explore classical queue designs in light of the importance of high hardware utilization as well as homogeneous computations and memory accesses across GPU threads.

The parallel execution of discrete-event simulations on commodity GPUs has been shown to achieve high event rates. Most previous proposals have focused on conservative synchronization, which typically extracts only limited parallelism in cases of low event density in simulated time. We present the design and implementation of an optimistic fully GPU-based parallel discrete-event simulator based on the Time Warp synchronization algorithm. The optimistic simulator implementation is compared with an otherwise identical implementation using conservative synchronization. Our evaluation shows that in most cases, the increase in parallelism when using optimistic synchronization significantly outweighs the increased overhead for state keeping and rollbacks. To reduce the cost of state keeping, we show how XORWOW, the default pseudo-random number generator in CUDA, can be reversed based solely on its current state. Since the optimal configuration of multiple performance-critical simulator parameters depends on the behavior of the simulation model, these parameters are adapted dynamically based on performance measurements and heuristic optimization at runtime. We evaluate the simulator using the PHOLD benchmark model and a simplified model of peer-to-peer networks using the Kademlia protocol. On a commodity GPU, the optimistic simulator achieves event rates of up to 81.4 million events per second and a speedup of up to 3.6 compared with conservative synchronization.

We present a simulation model of the Bitcoin peer-to-peer network, a widely deployed distributed electronic currency system. The model enables evaluations of the feasibility and cost of attacks on the Bitcoin network at full scale of 6,000 nodes. The simulation model is based on unmodified code from core segments of the Bitcoin reference implementation used by 99% of nodes. Parametrization of the model is performed based on large-scale measurements of the real-world network. We present preliminary validation results showing a reasonable correspondence of the propagation of messages in the Bitcoin network compared with simulation results. We apply the model to study the feasibility of a partitioning attack on the network and show that the attack is sensitive to the churn of the attacking nodes.

To achieve highest performance, parallel simulation of networks on modern hardware architectures depends on large numbers of independent computational tasks. However, the properties determining a network model's concurrency are still not well understood. In this paper, we propose an analytical model that enables concurrency estimations based on model knowledge and on statistics gathered from sequential simulation runs. In contrast to an automated concurrency analysis of event traces, the analytical approach enables insights into the relationship between the topology and communication patterns of the simulated network, and the resulting concurrency. We consider three fundamentally different network models as implemented in the network simulators PeerSim and ns-3: a large-scale application-layer peer-to-peer network, IP-based routing in a fixed topology, and a wireless ad-hoc network. For each model, we conduct an in-depth analysis, exposing the relationships between model characteristics and concurrency. Our analysis is validated by comparing estimated concurrency values to reference results of a trace-based analysis. The identification of key factors for concurrency forms a step towards a classification of network models according to their potential for parallelization.

Whether a given simulation model of a computer network will benefit from parallelization is difficult to determine in advance, complicated by the fact that hardware properties of the simulation execution environment can substantially affect the execution time of a given simulation. We describe SONSim, an approach to predict the execution time based on a simulation of an envisioned distributed network simulation (second-order simulation). SONSim takes into account both network model characteristics and hardware properties of the simulation execution environment. To show that a SONSim prototype is able to predict distributed performance with acceptable accuracy, we study three reference network simulation models differing fundamentally in topology and levels of model detail - simple topologies comprised of interconnected subnetworks, peer-to-peer networks and wireless networks. We evaluate the performance predictions for multiple configurations by comparing predictions for the three reference network models to execution time measurements of distributed simulations on physical hardware using both Ethernet and InfiniBand interconnects. In addition, utilizing the freedom to vary simulation hardware and model parameters in the second-order simulation, we demonstrate how SONSim can be used to identify general model characteristics that determine distributed simulation performance.

Distributed Hash Tables (DHTs) prove valuable for distributed architectures by providing distributed information lookup, routing, and data storage while promising good scalability and robustness at the same time. From this point of view, a DHT could be seen as a basic service that can be used to build distributed applications. Whereas today no widely deployed and publicly accessible basic DHT service exists and thus DHT-based applications have to deploy their very own DHT networks, DHTs consisting of millions of peers are formed by file sharing clients. Although the interfaces of typical DHTs used for file sharing are too narrow, a basic DHT service could probably be created by bundling a suitable client implementation with file sharing software. In this paper, we evaluate whether a basic DHT service could suit the needs of DHT- based applications in terms of stability, number of participating peers, the peers' session lengths, geographical distribution and peer connectivity when deployed similar to DHTs driven by file sharing. As these metrics mostly depend on end user behavior rather than on the DHT protocol, we report on measurement results gathered from monitoring of the BitTorrent Mainline client's DHT over six months. We analyze which metrics would fit a basic DHT service and which could prove problematic. Furthermore, we discuss resulting technical requirements for an appropriate DHT protocol.

In recent years, a trend towards the usage of physical layer models with increased accuracy can be observed within the wireless network community. This trend has several reasons. The consideration of signals - instead of packets - as the smallest unit of a wireless network simulation enables the ability to reflect complex radio propagation characteristics properly, and to study novel PHY/MAC/NET cross-layer optimizations that were not directly possible before, e.g. cognitive radio networks and interference cancellation. Yet, there is a price to pay for the increase of accuracy, namely a significant decrease of runtime performance due to computationally expensive signal processing. In this paper we study whether this price can be reduced - or even eliminated - if GPU-based signal processing is employed. In particular, we present and discuss four different architectures that can be used to exploit GPU-based signal processing in discrete event-based simulations. Our evaluation shows that the runtime costs can not be cut down completely, but significant speedups can be expected compared to a non GPU-based solution.

The distributed hash table (DHT) formed by BitTorrent has become very popular as a basis for various kinds of services. Services based on this DHT often assume certain characteristics of the DHT. For instance, for realizing a decentralized bootstrapping service a minimum number of peers running on a certain port are required. However, key characteristics change over time. Our measurements show that e.g. the number of concurrent users grew from 5 to over 7 millions of users during the last months. For making reliable assumptions it is thus essential to monitor the P2P network. This demo presents BitMON, a Java-based out-of-the-box platform for monitoring the BitTorrent DHT. This tool does not only crawl the network, but also automatically analyzes the collected data and visualizes the results. BitMON monitors the DHT's size in peers as well as the peers' IP addresses, port numbers, countries of origin and session length. Also, the long-term evolution of these indicators can be graphically displayed. Furthermore, BitMON is designed as a framework and can easily be extended or adapted to monitor other P2P networks.