Modern information infrastructures and organizations increasingly face the problem of data breaches and cyber-attacks. A traditional method for dealing with this problem are classification zones, such as ‘top secret’, ‘confidential’, and ‘unclassified’, which regulate the access of persons, hardware, and software to data records. In this paper, we present an approach that finds classification zone violations through automated message flow analysis. Our approach considers the problem of anonymization for the source event logs, which makes the resulting data flow model sharable with experts and the public. We discuss practical implications from applying the approach to a large governmental organization data set and discuss how the anonymity of our concept can be formally validated.

Future automotive software needs to deal with an increasing level of dynamicity, reasoned by the wish for connected driving, software updates, and dynamic feature activation. Such functionalities cannot be properly realized with today's classic AUTOSAR development approach, since it relies on the static configuration of all software units at build time.

Hybrid automata are a well-established modelling approach. The formalism is used in many real-time and control systems engineering projects, which makes model composition an increasingly relevant topic. A well-defined composition support allows concurrent engineering activities and the validation o f larger systems. However, many existing publications seldom consider it or make unrealistic assumptions on the model design. The article discusses the common problems with hybrid automata composition and presents a new formalism, called linear time-invariant hybrid automata (LTI-HA), which targets specifically these issues. Our approach considers the superposition principle for flow functions, which makes it specifically useful for practical modelling purposes in the spacecraft and control domain. We compare the approach to well-known related ideas, such as hybrid I/O automata. Several properties of composition, such as commutativity, are proven.

Modern distributed systems have reached a level of complexity where software bugs and hardware failures are no longer exceptional, but a permanent operational threat. This holds especially for cloud infrastructures, which need to deliver resources to their customers under well-defined service-level agreements. Dependability need to be assessed carefully. This article presents a structured approach for dependability stress testing in a cloud infrastructure. We automatically determine and inject the maximum amount of simultaneous non-fatal errors in different variations. This puts the existing resiliency mechanisms under heavy load, so that they are tested for their effectiveness in corner cases. The starting point is a failure space dependability model of the system. It includes the notion of fault tolerance dependencies, which encode fault-triggering relations between different software layers. From the model, our deterministic algorithm automatically derives fault injection campaigns that maximize dependability stress. The article demonstrates the feasibility of the approach with an assessment of a fault tolerant OpenStack cloud infrastructure deployment.

Dependability modeling and analysis relies on the usage of an unambiguous terminology model, in order to avoid misunderstandings and wrong interpretations. In both academia and industry, the most widely accepted approach is the fault-error-failure model, originally created by Avižienis and Laprie. Using this model for describing software faults and errors can help to establish a common vocabulary, but may lead to ambiguities, since the original `fault activation' term relates both to fault-enabling states and the execution of incorrect code. Our proposal encourages a more detailed description of fault activation conditions, while keeping the widely accepted basic vocabulary.

Blind Signal Separation is an algorithmic problem class that deals with the restoration of original signal data from a signal mixture. Implementations, such as Fast ICA, are optimized for parallelization on CPU or first-generation GPU hardware. With the advent of modern, compute centered GPU hardware with powerful features such as dynamic parallelism support, these solutions no longer leverage the available hardware performance in the best-possible way. We present an optimized implementation of the FastICA algorithm, which is specifically tailored for next-generation GPU architectures such as Nvidia Kepler. Our proposal achieves a two digit factor of speedup in the prototype implementation, compared to a multithreaded CPU implementation. Our custom matrix multiplication kernels, tailored specifically for the use case, contribute to the speedup by delivering better performance than the state-of-the-art CUBLAS library.

Modern server and desktop systems combine multiple computational cores and accelerator devices into a hybrid architecture. GPUs as one class of such devices provide dedicated processing power and memory capacities for data parallel computation of 2D and 3D graphics. Although these cards have demonstrated their applicability in a variety of areas, they are almost exclusively used by special purpose software. If such software is not running, the accelerator resources of the hybrid system remain unused. In this paper, we present an operating system extension that allows leveraging the GPU accelerator memory for operating system purposes. Our approach utilizes graphics card memory as cache for virtual memory pages, which can improve the overall system responsiveness, especially under heavy load. Our prototypical implementation for Windows proves the potential of such an approach, but identifies also significant preconditions for a widespread adoption in desktop systems.

Dependability modeling is a widely established method for analyzing the reliability of complex systems. Nearly all approaches focus on the representation - in success or failure space - of one specific system configuration. This does not reflect the high configurability of systems being common today. Furthermore, in order to perform a quantitative analysis of a model, the reliability engineer also needs to add exact event probabilities that can often only be estimated. Both things together lead to a situation where the final model may persuade the reader of an exactness that does not correspond with reality. We present an extended version of fault trees called Fuzz Trees. They combine fuzzy numbers for event probabilities with the modeling of system variability by new graphical notations. The concept allows the engineer to make uncertainty an explicit part of the dependability model, and to evaluate design alternatives early in the development. We discuss an initial analysis algorithm that allows the comparison of failure probabilities and costs for all possible system configurations being modeled by such a tree.

SUMMARY Over many decades, advances in computer system design and processor manufacturing have resulted in an ever‐increasing per‐chip transistor count, which, in combination with increased clock frequencies, has led to a tremendous increase in single‐thread performance in desktop and server CPUs. The trend to higher integration in processor manufacturing will continue for the next couple of years. However, the increased transistor count leads to additional compute cores within a CPU, rather than to an increased single‐thread performance. Programming and utilizing these future CPUs impose a number of problems commonly referred to as themulticore challenge. These trends primarily affect server computers, whereas on client systems, a break‐even between users' willingness to pay for compute power and today's CPU implementation seems to be reached. In this paper, we argue that the full exploitation of many‐core architectures on the server demands better support by the operating system. This relates to the support of new application programming models, the seamless integration of internal and external services, security, as well as on monitoring and (self‐adaptive) management of such server environments. Within this paper, we discuss three major trends that will drive the adoption of server operating systems to modern many‐core hardware: dynamic parallelism, dynamic partitioning, and dynamic provisioning. Copyright © 2011 John Wiley & Sons, Ltd.

Physical memory faults are one of the accepted reliability threats for modern processor technology. Even though error correction for memory hardware can deal with this class of fault, many processor designs such as X86 do not invest semiconductor complexity and space to deal with multi-bit faults in caches and registers. In this paper, we analyze how the right choice of compiler options can act as software-based error prevention strategy for register file faults. This investigation is based on a classification scheme for GCC compiler options and a new fault injection environment for automated experiments. The study proves the the initial hypothesis that reliability improvements mainly depend on the algorithmic structure of the application under test. A small number of compiler options have proven to be a feasible application-independent error mitigation strategy.

Multi-agent based simulation (MABS) is a discrete event simulation technique used to study complex systems with entities having social and autonomous behavior. MABS applications are characterized by unpredictable execution behavior and high communication-to-computation ratio. In this paper, we propose an adaptation strategy to support efficient execution of large-scale MABS applications on typical Grid infrastructures. To achieve this objective, the behavior of MABS applications and the execution environment is investigated, in order to constantly obtain performance prediction models. These models will then be used to realize dynamic load balancing and resource allocation schemes. We discuss our basic approach, initial experimental results, the planned future research and an application of our research in the transportation and logistics simulation domain.

Today's cluster and grid environments demand the usage of product-specific APIs and tools for developing distributed applications. We give an overview of the distributed resource management application API (DRMAA) specification, which defines a common interface for job submission, control, and monitoring. The DRMAA specification was developed by the authors at the open grid forum standardization body, and has meanwhile significant adoption in academic and commercial cluster systems. Within this paper, we describe the basic concepts of the finalized API, and explain issues and findings with the standardization of such an unified interface.