Real-Time Online Interactive Applications (ROIA), e.g., multiplayer online games and simulation-based e-learning, are emerging internet applications that make high Quality of Service (QoS) demands on the underlying network. These demands depend on the number of users and the actual application state and, therefore, vary at runtime. Traditional networks have very limited possibilities of influencing the network behaviour to meet the dynamic QoS demands, such that most ROIA use the underlying network on a best-effort basis. The emerging architecture of Software-Defined Networking (SDN) decouples the control and forwarding logic from the network infrastructure, making the network behaviour programmable for applications. This paper analyses ROIA requirements on the underlying network and describes the specification of an SDN Northbound API that allows ROIA applications to specify their dynamic network requirements and to meet them using SDN networks.

We aim at enhancing the Quality of Service (QoS) management in modern Internet applications that heavily rely on the quality of the underlying network. Our goal is to provide the application developers with mechanisms for specifying and controlling high-level, application-related QoS metrics, rather than the traditional low-level, network-related metrics like latency, throughput, packet loss, etc. We study this problem for the challenging class of Real-Time Online Interactive Applications (ROIA) which include, e.g., multiplayer online games and simulation-based e-learning and training. We leverage the dynamic management features of Software-Defined Networking (SDN) to express, monitor and control applications' QoS demands. Our particular contributions are as follows: 1) we propose a Northbound API for specifying the application-level QoS requirements in ROIA, 2) we demonstrate how the applicationlevel metric "response time" can be automatically translated into network-level metrics understood by the SDN controller, and 3) we report experimental results on managing application-level QoS in an example online game on an OpenFlow-enabled testbed.

Time Online Interactive Applications (ROIA), e.g., multiplayer online games and simulation-based e-learning, make high Quality of Service (QoS) demands on the underlying network. These demands depend on the number of users and the actual application state and, therefore, vary at runtime. Traditional networks have very limited possibilities of influencing the network behavior to meet the dynamic QoS demands, such that most ROIA use the underlying network on a best-effort basis. The emerging Software-Defined Networking (SDN) technology decouples the control and forwarding logic from the network infrastructure, making the network behavior programmable for applications. This paper analyses ROIA requirements on the underlying network and describes the specification and design of an SDN Northbound API that allows ROIA applications to specify their dynamic network requirements and to meet them at runtime using SDN networks.

Writing and optimizing programs for high performance on systems with GPUs remains a challenging task even for expert programmers. One promising optimization technique is to evaluate parts of the program upfront on the CPU and embed the computed results in the GPU code allowing for more aggressive compiler optimizations. This technique is known as multi-stage programming and has proven to allow for significant performance benefits. Unfortunately, to achieve such optimizations in current GPU programming models like OpenCL, programmers are forced to manipulate the GPU source code as plain strings, which is error-prone and type-unsafe.In this paper we describe PACXX -a GPU programming approach using modern C++ standards, with the convenient features like type deduction, lambda expressions, and algorithms from the standard template library (STL). Using PACXX, a GPU program is written as a single C++ program, rather than two distinct host and kernel programs. We extend PACXX with an easy-to-use and typesafe API for multi-stage programming avoiding the pitfalls of string manipulation. Using just-in-time compilation techniques, PACXX generates efficient GPU code at runtime.Our evaluation shows that using PACXX allows for writing multi-stage code easier and safer than currently possible. Using two detailed application studies we show that multi-stage programming can significantly outperform equivalent non-staged programs. Furthermore, we show that PACXX generates code with performance comparable to industrial-strength OpenCL compilers.

No abstract

No abstract

In this paper, we advocate a composable approach to programming systems with Graphics Processing Units (GPU): programs are developed as compositions of generic, reusable patterns. Current GPU programming approaches either rely on low-level, monolithic code without patterns (CUDA and OpenCL), which achieves high performance at the cost of cumbersome and error-prone programming, or they improve the programmability by using pattern-based abstractions (e.g., Thrust) but pay a performance penalty due to inefficient implementations of pattern composition.We develop an API for GPUs based programming on C++ with STL-style patterns and its compiler-based implementation. Our API gives the application developers the native C++ means (views and actions) to specify precisely which pattern compositions should be automatically fused during code generation into a single efficient GPU kernel, thereby ensuring a high target performance. We implement our approach by extending the range-v3 library which is currently being developed for the forthcoming C++ standards. The composable programming in our approach is done exclusively in the standard C++14, with STL algorithms used as patterns which we re-implemented in parallel for GPU. Our compiler implementation is based on the LLVM and Clang frameworks, and we use advanced multi-stage programming techniques for aggressive runtime optimizations.We experimentally evaluate our approach using a set of benchmark applications and a real-world case study from the area of image processing. Our codes achieve performance competitive with CUDA monolithic implementations, and we outperform pattern-based codes written using Nvidia's Thrust.[Copyright notice will appear here once 'preprint' option is removed.]

No abstract