Mirko Stoffers

Comparing the ns-3 Propagation Models

An important aspect of any network simulation that models wireless networks is the design and implementation of the Propagation Loss Model. The propagation loss model is used to determine the wireless signal strength at the set of receivers for any packet being transmitted by a single transmitter. There are a number of different ways to model this phenomenon, and these vary both in terms of computational complexity and in the measured performance of the wireless network being modeled. In fact, the ns -- 3 simulator presently has 11 different loss models included in the simulator library. We performed a detailed study of these models, comparing their overall performance both in terms of the computational complexity of the algorithms, as well as the measured performance of the wireless network being simulated. The results of these simulation experiments are reported and discussed. Not surprisingly, we observed considerable variation in both metrics.

Automated Memoization for Parameter Studies Implemented in Impure Languages

In computer simulations many processes are highly repetitive. These repetitions are amplified further when a parameter study is conducted where the same model is repeatedly executed with varying parameters, especially when performing multiple runs to increase statistical confidence. Inevitably, such repetitions result in the execution of identical computations, with identical code, identical input, and hence identical output. Performing computations redundantly wastes resources and the execution time of a parameter study could be reduced if the redundancies were avoided. To this end, the idea of memoization was proposed decades ago. However, until today memoization is either performed manually or automated memoization approaches are used that can only handle pure functions. This means that only the function parameters and the return value may be input and output of the function whereas side effects are not allowed. In order to expand the scope of automated memoization to a larger class of programs, we propose an approach able to reliably detect the full input and output of a function, including reading and writing objects through arbitrarily indirect pointers with some preconditions. We show the feasibility of our approach and derive simple performance approximations enabling rough predictions of the expected benefit. By means of a simple case study performing an OFDM network simulation, we demonstrate the practical suitability of our approach, speeding up the execution of the whole parameter study by a factor of 75, while only doubling memory consumption.

Parallel Expanded Event Simulation of Tightly Coupled Systems

The technical evolution of wireless communication technology and the need for accurately modeling these increasingly complex systems causes a steady growth in the complexity of simulation models. At the same time, multi-core systems have become the de facto standard hardware platform. Unfortunately, wireless systems pose a particular challenge for parallel execution due to a tight coupling of network entities in space and time. Moreover, model developers are often domain experts with no in-depth understanding of parallel and distributed simulation. In combination, both aspects severely limit the performance and the efficiency of existing parallelization techniques. We address these challenges by presenting parallel expanded event simulation, a novel modeling paradigm that extends discrete events with durations that span a period in simulated time. The resulting expanded events form the basis for a conservative synchronization scheme that considers overlapping expanded events eligible for parallel processing. We then put these concepts into practice by implementing Horizon, a parallel expanded event simulation framework specifically tailored to the characteristics of multi-core systems. Our evaluation shows that Horizon achieves considerable speedups in synthetic as well as real-world simulation models and considerably outperforms the current state-of-the-art in distributed simulation.

On Automated Memoization in the Field of Simulation Parameter Studies

Processes in computer simulations tend to be highly repetitive. In particular, parameter studies further exasperate the situation as the same model is repeatedly executed with only partially varying parameters. Consequently, computer simulations perform identical computations, with identical code, identical input, and hence identical output. These redundant computations waste significant amounts of time and energy. Memoization, dating back to 1968, enables the caching of such identical intermediate results, thereby significantly speeding up those computations. However, until now, automated approaches were limited to pure functions. At ACM SIGSIM-PADS 2016 we published, to the best of our knowledge, the first practical approach for automated memoization for impure code. In this work, we extend this approach and evaluate the performance characteristics of a number of extensions that deal with questions posed at PADS: (1) To reduce and bound the memory footprint, we investigate several cache eviction strategies. (2) We allow the original and the memoized code to coexist via a runtime-switch and analyze the crossover point, thereby mitigating memoization overhead. (3) By optionally persisting the Memoization Cache to disk, we expand the scope to exploratory parameter studies where cached results can now be reused across multiple simulation runs. Altogether, automated memoization for impure code is a valuable technique, the versatility of which we explore further in this article. It sped up a case study of an OFDM network simulation by a factor of more than 80 with an only marginal increase of memory consumption.

Automated memoization: automatically identifying memoization units in simulation parameter studies

Simulations, and in particular large scale parameter studies, typically exhibit a considerable amount of redundancies. These redundancies can be avoided by memoization, a technique that stores and re-uses intermediate results. This requires a Memoization Unit (MU) to be identified first and then transformed. We have recently enabled the automation of the second step to also be applicable to impure computations, allowing it to become a valuable tool for the modeling and simulation domain. However, the first step still needs to be performed manually. Hence, the user needs to understand the model and the concept of memoization well enough to specify which computations to annotate for memoization. In this paper, we describe our approach to automatically identify memoization-worth computations. Input to this algorithm is an unmodified parameter study. After identifying the most promising memoization opportunities, we use the existing automated memoization tool to create a memoized parameter study, which can then be executed quickly. Our evaluation shows that our automated approach is able to identify those MUs that previously had to be annotated manually. This identification takes less than 2 minutes for a case study that without memoization takes several hours.

Analyzing Data Dependencies for Increased Parallelism in Discrete Event Simulation

To parallelize simulations, independent events have to be identified, which can be executed concurrently. The highest level of parallelism is achieved if the number of events identified as independent is maximized. Traditionally, this identification is based on time and location of events, only allowing parallelization if events on the same simulation entity are executed in timestamp order. To increase the level of parallelism, we propose a novel approach investigating another criterion for independence: If two events on the same simulation entity do not access the same data items in a conflicting manner, they can as well be executed in parallel. To this end, we propose static analysis of the model code for data access. To ease this process we develop the simulation language PSimLa similar to C++ but modified where necessary to increase analyzability without removing essential C++ features. First evaluation results show the potential of this approach and increase the confidence that data-dependency analysis can improve future parallel simulation.

Circuit Switched VM Networks for Zero-Copy IO

Although applications are nowadays often executed in virtual machines (VMs) to isolate applications or consolidate physical machines, VM network performance is still challenging. Packetization, encapsulation, congestion control, preparations for loss, and copying of data introduce unnecessary performance degradation within a system where VMs communicate over abundant and reliable shared-memory. Although protocols like TCP are therefore not well suited for kernel network stack in VMs, preexisting applications require the kernel socket interface to keep functioning. In eliminating the unnecessary overhead for inter-VM communication and shifting it to the host operating system for communication over a physical NIC, our approach increases performance for both cases of communicating with another VM on the same host and for communicating with external hosts. Instead of multiplexing multiple connections over a single virtual Ethernet link, we use a separate shared-memory connection for each VM application socket. Our approach improves the stream and datagram performance of existing applications over an unmodified socket interface and brings the benefits of memory-mapped zero-copy IO to modified applications without sacrificing isolation between sockets.

Code-transparent Discrete Event Simulation for Time-accurate Wireless Prototyping

Exhaustive testing of wireless communication protocols on prototypical hardware is costly and time-consuming. An alternative approach is network simulation, which, however, often strongly abstracts from the actual hardware. Especially in the wireless domain, such abstractions often lead to inaccurate simulation results. Therefore, we propose a code-transparent discrete event simulator that enables a direct simulation of existing code for wireless prototypes. With a focus on lower layers of the communication stack, we enable a parametrization of the simulation timings based on real-world measurements to increase the simulation accuracy. Our evaluation shows that we achieve close results for throughput (deviation below 3% for UDP and latency (corrected deviation about 13% compared to real-world setups, while providing the benefits of code-transparent simulation, i.e., to flexibly simulate large topologies with existing prototype code. Moreover, we demonstrate that our approach finds implementation defects in existing hardware prototype software, which are otherwise difficult to track down in real deployments.

Dynamic algorithm selection for the logic of tasks in IoT stream processing systems

Various Internet of Things (IoT) and Industry 4.0 use cases, such as city-wide monitoring or machine control, require low-latency distributed processing of continuous data streams. This fact has boosted research on making Stream Processing Frameworks (SPFs) IoT-ready, meaning that their cloud and IoT service management mechanisms (e.g., task placement, load balancing, algorithm selection) need to consider new requirements, e.g., ultra low latency due to physical interactions. The algorithm selection problem refers to selecting dynamically which internal logic a deployed streaming task should use in case of various alternatives, but it is not sufficiently supported in current SPFs. To the best of our knowledge, this work is the first to add this capability to SPFs. Our solution is based on i) architectural extensions of typical SPF middleware, ii) a new schema for characterizing algorithmic performance in the targeted context, and iii) a streaming-specific optimization problem formulation. We implemented our solution as an extension to Apache Storm and demonstrate how it can reduce stream processing latency by up to a factor of 2.9 in the tested scenarios.

Data Dependency based Parallel Simulation of Wireless Networks

Simulation of wireless systems is highly complex and can only be efficient if the simulation is executed in parallel. To this end, independent events have to be identified to enable their simultaneous execution. Hence, the number of events identified as independent needs to be maximized in order to increase the level of parallelism. Traditionally, dependencies are determined only by time and location of events: If two events take place on the same simulation entity, they must be simulated in timestamp order. Our approach to overcome this limitation is to also investigate data-dependencies between events. This enables event reordering and parallelization even for events at the same simulation entity. To this end, we design the simulation language PSimLa, which aids this process. In this paper, we discuss the PSimLa design and compiler as well as our data-dependency analysis approach in detail and present case studies of wireless network models, speeded up by a factor of 10 on 12 cores where time-based parallelization only achieves a 1.6x speedup.