Time-Sensitive Networking (TSN) extends Ethernet to enable deterministic networking making it suitable for latency-sensitive industrial applications. To ensure bounded end-to-end delays and minimal jitter, a network-wide communication schedule with exclusively reserved transmission slots is enforced for time-triggered hard realtime traffic. While numerous scheduling methodologies exist for generating such schedules, their practical applicability remains uncertain. In this paper, we present a testbed for evaluating the real-world suitability of TSN schedules. We describe the hardware and software setup and demonstrate our evaluation methodology.

Time-Sensitive Networking (TSN) facilitates the implementation of realtime data traffic with deterministic delay and jitter in Ethernet networks. In its time-triggered communication variant, network paths as well as transmission time slots along the paths need to be planned and reserved for all data streams, respectively. Conventionally, such a feasible (i. e., realtime compliant) network schedule is computed and optimized offline, installed upon deployment, and cannot be changed anymore at runtime without stopping the communication. The latter becomes unsuitable for future industrial use cases with a growing demand for flexibility including schedule adjustments. In this paper, we present an online scheduler capable to incrementally integrate new streams at runtime and to adapt the existing schedule, if necessary, while retaining the realtime guarantees given to active streams. For this purpose, the scheduling heuristic identifies streams whose adjustment requires minimal reconfiguration efforts. In a thorough evaluation, we analyze the scheduler's trade-off between resource usage and schedule quality showing its suitability for diverse application scenarios.

Time-Sensitive Networking (TSN) disrupts realtime communication technology by making IEEE Ethernet realtime-capable. For time-triggered, hard realtime traffic, TSN provides standardized mechanisms to reserve communication paths as well as individual transmission time slots for data frames. By leveraging these means in a precomputed network schedule, TSN allows for bounded end-to-end delays and minimal jitter. Not being part of the IEEE standard, corresponding scheduling algorithms are an active field of research. Unfortunately, due to differing model assumptions, evaluation setups, and key metrics, a fair comparison of schedulers is impossible so far. In this paper, we present a systematic and reproducible approach to benchmark TSN schedulers. First, we provide a scheduler taxonomy that enables to cluster schedulers by their characteristics. Second, we analyze interactions of input parameters and scheduler results to derive a benchmarking parcour for quantitative comparisons. Finally, we use the approach to benchmark existing schedulers and show subtle interaction effects. This way, our approach enables—for the first time-comparability between schedulers, fueled by the public availability of our benchmarking scenarios.

SSD-based block-level caches can notably increase the performance of HDD-based storage systems. However, this demands a sensible choice of the cache block size, which depends strongly on the workload characteristics. Many workloads will most likely favor either small or large cache blocks. Unfortunately, choosing the appropriate cache block size is difficult due to the diversity and dynamics of storage workloads. Thus, adapting the cache block size to the workload characteristics at run time has the potential to substantially improve the cache performance compared to using a fixed cache block size. However, changing the used cache block size for all cached data is very costly and neglects that distinct parts of the data may exhibit different access patterns, which favor distinct cache block sizes.In this paper, we experimentally study the performance impact of the cache block size and fine-grained adaptation, i.e., for individual parts of the data, between small and large cache blocks in write-back SSD caches. Based on our results, we make two major observations on the performance impact of the cache block size and its adaptation. First, using an inappropriate cache block size can reduce the overall throughput by up to 84% compared to using the most suitable cache block size. Second, fine-grained adaptation between small and large cache blocks is highly beneficial as it avoids such a performance deterioration, whereas it can increase the overall throughput by up to 126% in comparison to using the more suitable fixed cache block size.

Future applications of the Industrial Internet of Things will increasingly depend on the timely exchange of information and data. Time-Sensitive Networking, which is currently being standardized, therefore extends switched Ethernet networks by realtime communication capabilities offering deterministic message delays. In its time-triggered communication variant, a network path needs to be planned for each realtime data flow and corresponding transmission time slots have to be reserved on the network links along that path. In this paper, we present the first joint mathematical model for path routing and time slot scheduling that combines multicast support with an individual transmission scheduling on each link along a flow's path. We provide a formalization as an Integer Linear Programming (ILP) problem and discuss several optimizations to significantly reduce the ILP solver's runtime without affecting the solution quality. In a thorough evaluation, we show the applicability of our approach and analyze the effects and trade-offs of different objective functions.

Due to a notably higher cost per bit of storage capacity, NAND flash memory solid state drives (SSDs) are not expected to completely replace hard disk drives (HDDs) in the near future. Using SSDs as a cache for HDDs, however, proved very effective in increasing the performance of storage systems. The performance increase depends strongly on both the SSD cache design and the workload applied to the storage system. However, distinct parts of the data may exhibit significantly different access patterns that potentially change rapidly and unpredictably over time. This particularly applies to complex dynamic systems, such as virtualized environments. Existing SSD cache architectures are not able to exploit such differences in access patterns, as they only use a single cache design, even when adapting certain cache parameters.In this paper, we propose a novel generic architecture for adaptive block-level SSD caches that simultaneously employs multiple SSD caches with complementary designs. The goal is to use for each kind of access pattern the SSD cache design that fits the pattern best. Results of our experimental evaluation show that the proposed SSD cache architecture adapts to different workloads well. For a broad range of workloads, it provides an overall throughput that is comparable to the respective best single cache design, whereas it is able to outperform these cache designs for superimposed mixed workloads and workloads with changing characteristics.

Solid-state drives (SSD) based on flash memory offer the opportunity to build high-performance storage systems with low energy consumption and high reliability. Crucial concerns of current SSDs are their write performance, especially for small random requests, and the limited lifespan of their flash memory. Both can be mitigated by providing an SSD with information about the stored data. This may include notifications about deal location of storage capacity or the prevalent access type. Knowing the size, latency requirements and type of upcoming requests can help to improve the dataset management (DSM) of an SSD allowing further performance improvement and memory lifetime extension. Often such information has to be passed through intermediate layers (e.g., RAIDs) placed between the information sources (e.g., file system) and the information sinks (i.e., the SSDs). Problems arise because such layers often do not appropriately propagate DSM commands making the intended optimizations unfeasible. In this paper, we propose a file system-independent, layered I/O software architecture that enables the handling of DSM commands throughout all of the layers. Moreover, it allows to address cross-cutting concerns related to the propagation of DSM commands. Its applicability is demonstrated by an exemplary instance based on stacked software RAID layers. The results of an experimental evaluation based on Linux Software RAID clearly show the benefits of the proposed architecture.

Solid-State Drives (SSDs) are about to radically change the way we look at storage systems. Without moving mechanical parts, they have the potential to supplement or even replace hard disks in performance-critical applications in the near future. Storage systems applied in such settings are usually built using RAIDs consisting of a bunch of individual drives for both performance and reliability reasons. Most existing work on SSDs, however, deals with the architecture at system level, the ash translation layer (FTL), and their influence on the overall performance of a single SSD device. Therefore, it is currently largely unclear whether RAIDs of SSDs exhibit different performance and reliability characteristics than those comprising hard disks and to which issues we have to pay special attention to ensure optimal operation in terms of performance and reliability.

The performance of Web servers and application servers is a crucial factor for the success of the underlying business activity. Current commercial servers (such as Apache and Microsoftpsilas IIS) usually employ a thread-based concurrency policy for executing request simultaneously. However, with this policy the throughput tends to collapse when massive overload occurs. Event-based concurrency has been proposed as an alternative, but - similar to the thread-based approach - it suffers in its pure form from a potential memory access bottleneck. This is avoided by a server based on a staged event-driven architecture (SEDA) which combines the two approaches to take advantage of locality in data and code within each state. In this paper, we present a three layer observer/controller architecture for dynamic performance control of SEDA-based application servers. Control is achieved by a strategy which adapts the resources assigned to each stage based on the observed throughput and queue length of each stage using a feedback loop. To validate our strategy and to compare with other strategies, we implemented a simulation environment. The results gained demonstrate that our approach successfully self-optimizes the CPU time allocation and achieves a competitive system throughput while avoiding performance degradation under overload and dynamic changes in the system.

The correctness of systems is frequently proved by demonstrating the non-reachability of certain (incorrect) states with the help of formal frameworks, e.g., Petri nets. Especially for real-time systems, the timely behavior has to be considered. Thus, there exist several extensions that allow the modeling of time in Petri nets. Non-reachability proofs in time-dependent Petri nets are usually done by proving the non-reachability within the time-less skeleton. However, in many cases this approach fails to prove non-reachability, since the skeleton can reach more markings than the timedependent Petri net. In this paper, we introduce a state equation for a class of time-augmented Petri nets and demonstrate in an example application how this state equation can be used to prove non-reachability within the actual timedependent net.

The provisioning of ambient services is gaining importance as users become more and more embedded in environments that are saturated with electronic devices. In our previous work, we have proposed the ad hoc service grid (ASG) approach as a means for deliberately setting up an infrastructure for providing ambient services at medium-sized locations like shopping malls. In this paper, we introduce a self-repairing lookup service architecture that is able to handle dynamic services in an AGS. These services can autonomously replicate and migrate within an ASG to optimize resource usage and message latency. Our lookup service is able to cope with the inconsistencies caused by service migrations efficiently by applying a lazy, request-driven update protocol. We discuss the architecture and the protocols employed by the lookup service. Moreover, we provide experimental results that show the efficiency and effectiveness of our approach

When a composition of Web services is designed, available services are put together to form a defined flow of executions. In a discovery process, a trader proposes available Web services as potential candidates. In a succeeding selection, for each task a trader chooses one candidate to form the optimal composition due to selection criteria. This paper discusses how the selection can consider different quality-of-service (QoS) categories to determine the most suitable candidates for the composition. If more than one category is used for optimisation, a multi-dimensional optimisation problem arises. This mentions similarities to similar combinatorial problems. Then, possible solutions are proposed and their performance is evaluated.

Publish/subscribe is becoming increasingly popular as it provides means for decoupled communication. One important issue for increasing the success of publish/subscribe middleware is to make them fault tolerant. Classical fault-tolerance mechanisms apply redundancy to mask certain faults. However, if a fault cannot be masked, it is not guaranteed that the system ever returns to normal operation. In contrast to that, self-stabilizing systems recover from arbitrary transient faults provided that faults do not continue to occur until the system is stable again. However, while the system stabilizes, it may not exhibit the desired behavior. In this paper, we present the first comprehensive analysis of publish/subscribe systems including self-stabilization, giving an alternative to extensive simulations. The analysis is based on continuous time birth-death Markov Chains and investigates the characteristics of publish/subscribe systems in equilibrium. We give closed analytical solutions for the sizes of routing tables, for the overhead required to keep the routing tables up-to-date, and for the leasing overhead required for self-stabilization. To judge the efficiency of self-stabilizing routing, we compare it to flooding which is the naive implementation of a self-stabilizing publish/subscribe system.