Effective cross-platform, multilevel parallelism via dynamic adaptive execution

The unbounded version of the 1D range assignment problem for radio-stations is studied. Here a set of n radio stations are placed arbitrarily on a line. The objective is to assign ranges to these radio-stations such that the total power consumption is minimum. A simple incremental algorithm is proposed which produces optimum solution in O(n3) time and O(n2) space. This improves the running time of the best known existing algorithm by a factor of n.

GODIVA (GODdard Instrumentation Visualizer and Analyzer) is a software system for instrumentation and performance analysis of large Fortran and C science codes executing on scalable parallel systems, including traditional MPPs and Beowulf-class clusters. The system consists of an annotation “language” used to add annotations to Fortran or C codes, a preprocessor for translating annotated codes into standard Fortran or C with embedded calls to the Godiva run-time library, the run-time library itself, and a set of postprocessors for generating analyses of instrumentation data collected during program execution. This paper provides an overview of the system and discusses several of the most important and unique design decisions that differentiate Godiva from other performance measurement systems.

We describe the tools and interfaces created by the AGEDIS project, a European Commission sponsored project for the creation of a methodology and tools for automated model driven test generation and execution for distributed systems. The project includes an integrated environment for modeling, test generation, test execution, and other test related activities. The tools support a model based testing methodology that features a large degree of automation and also includes a feedback loop integrating coverage and defect analysis tools with the test generator and execution framework. Prototypes of the tools have been tried in industrial settings providing important feedback for the creation of the next generation of tools in this area.

We describe the tools and interfaces created by the AGEDIS project, a European Commission sponsored project for the creation of a methodology and tools for automated model driven test generation and execution for distributed systems. The project includes an integrated environment for modeling, test generation, test execution, and other test related activities. The tools support a model based testing methodology that features a large degree of automation and also includes a feedback loop integrating coverage and defect analysis tools with the test generator and execution framework. Prototypes of the tools have been tried in industrial settings providing important feedback for the creation of the next generation of tools in this area.

We describe the tools and interfaces created by the AGEDIS project, a European Commission sponsored project for the creation of a methodology and tools for automated model driven test generation and execution for distributed systems. The project includes an integrated environment for modeling, test generation, test execution, and other test related activities. The tools support a UML based testing methodology that features a large degree of automation and also includes a feedback loop integrating coverage and defect analysis tools with the test generator and execution framework.

Despite maturing in many ways, heterogeneous distributed computing platforms continue to require substantial effort in terms of software installation and management for efficient use, often necessitating manual intervention by resource providers and end-users. In this paper we propose a novel model of resource sharing that is a viable alternative to that commonly adopted in the grid community. Our model, termed Unibus, shifts the resource virtualization and aggregation responsibilities to the software at the client side, taking these burdens away from resource providers. Drawing from parallels with operating systems, we argue that distributed resources may be unified and aggregated at the user's end, in a manner similar to ordinary peripheral devices. Running on the user's access device, the overlay system software can virtualize remote resources via dynamically deployed software mediators analogous to device drivers, reconfiguring the resources if necessary via "firmware" modules. To illustrate the feasibility of the Unibus model, we have prototyped a development toolkit automating the installation, build, run, and post-processing stages of MPI applications. Through the provided console, this toolkit can deploy and configure an MPI execution environment across a set of heterogeneous, isolated distributed resources, turning them into a coherent virtual machine with a single interface point. We conducted a series of experiments with the NAS Parallel Benchmarks. Results indicate that the toolkit preserves the application performance of "bare" MPI, while substantially reducing maintenance and configuration efforts. Overall, the results suggest that the envisioned client side overlay model for resource sharing may potentially be able to address some of long-standing obstacles in building heterogeneous HPC systems.

Legacy program execution system, which is necessary for grid to enable users to reuse all legacy programs without reengineering source codes, is still an open problem. We propose general running service (GRS) as a legacy program execution framework to solve two of the most important problems, shielding heterogeneousness of all kinds target system and exactly configuring complex execution environments required by legacy program. In this paper, we first abstract the task model of grid task as the core of our execution framework, following with some conceptions of GRS are provided including application deployment, JSDL job submission and target system adapter. And then the detail of GRS implementation in ChinaGrid Support Platform (CGSP) is provided. Furthermore, the performance of GRS through comparing with GRAM of GT4 is also evaluated

The proliferation of service-oriented architectures in the last decade has brought forward an important class of sophisticated distributed applications that are founded on the idea of composing multiple simple services into a complex, coherent whole. Such applications spanning multiple service invocations can be most effectively realized by means of workflows. When it comes to high performance workflow execution, distribution (outscaling) of services is a key concept and also a very straightforward advantage of the workflow paradigm. Concretely, both the constituent services of the workflow and the system that manages their invocations have to be distributed across an environment of computational devices. In a wide spectrum of applications, that entail heterogeneity of the encompassed computational devices, e.g., modern emergency management, invocations of optimal service instances in conjunction to their reliability are fundamental prerequisites of distributed workflow management. At the center of this thesis is a formal model that defines the distributed (i.e., scalable) execution of workflows. To extend this model for reliability in a novel way, which does not affect the scalability of execution, the Safety-Ring system service is presented. The idea behind Safety-Ring is to offer recovery for a wide range of node failures, which host active services of running workflows. To this end, the Safety-Ring provides a scalable, reliable, and consistent data store that is used for the storage of workflow execution state. The novel failure-recovery mechanism features effective reliability such that can be applied on the nodes that host the Safety-Ring service themselves, thus we say the Safety-Ring is self-healing. To apply the reliable (and distributed) execution model, enhanced by Safety-Ring, to heterogeneous node environments, that are predominantly composed of mobile de- vices, this thesis presents the Compass data access protocol. In providing scalable data lookup for its maintained data, the Safety-Ring assumes network runtime characteristics which are rather stable, and thus Safety-Ring implicitly optimizes for the number of queried nodes. Especially in mobile applications, where node network connectivity dynamically changes, data access protocols should aim at reducing the overall data lookup latency, rather than the number of queried nodes. Compass introduces latency optimal paths to each node, which dynamically adapt to changing network characteristics. The scalable data lookup of Safety-Ring is not affected. In case distributed execution of workflows spans services of continuous (stateful) type, their reliability is decoupled from the Safety-Ring. Since such service types are predominantly featured by devices of limited resources, novel approaches to resource conservative recovery of failures for continuous services have to be provided. This thesis builds on proven recovery techniques, such as passive-standby, so as to enhance them for redundancy of the continuous state and thus improve the overall reliability of the system. In doing so the redundancy of state is enforced by means of a lightweight, in terms of network overhead, consistency protocol which allows for its application in resource limited node environments. In order to improve the execution performance of distributed workflows, in terms of throughput, this thesis offers a novel concept to services distribution. At the heart of our approach lie decentralized controllers that autonomously perform dynamic reconfiguration of the execution environment in terms of available services. This primarily affects the Safety-Ring service and all application services. Thereby, the goals of the controllers are to prevent workflow execution bottlenecks and unnecessary service deployments that waste resources. Since the controllers are equipped at any node in the system and can affect any other node of the system we say that the distributed workflow execution model is self-optimizing. Finally, all the presented concepts are implemented within the context of the OSIRIS distributed workflow engine and quantitatively evaluated in a series of experiments. The results of experiments confirm the benefits of our concepts for the distributed workflow execution model.

Building applications and information systems increasingly means dealing with concurrency and faults stemming from distribution of system components. Atomic transactions are a well-known method for transferring the responsibility for handling concurrency and faults from developers to the software's execution environment, but incur considerable execution overhead. This dissertation investigates methods that shift some of the burden of concurrency control into the network layer, to reduce response times and increase throughput. It anticipates future programmable network devices, enabling customized high-performance network protocols.\nWe propose Atomic Transfer (AT), a distributed algorithm to prevent race conditions due to messages crossing on a path of network switches. Switches check request messages for conflicts with response messages traveling in the opposite direction. Conflicting requests are dropped, obviating the request's receiving host from detecting and handling the conflict. AT is designed to perform well under high data contention, as concurrency control effort is balanced across a network instead of being handled by the contended endpoint hosts themselves.\nWe use AT as the basis for a new optimistic transactional cache consistency algorithm, supporting execution of atomic applications caching shared data. We then present a scalable refinement, allowing hierarchical consistent caches with predictable performance despite high data update rates.\nWe give detailed I/O Automata models of our algorithms along with correctness proofs. We begin with a simplified model, assuming static network paths and no message loss, and then refine it to support dynamic network paths and safe handling of message loss.\nWe present a trie-based data structure for accelerating conflict-checking on switches, with benchmarks suggesting the feasibility of our approach from a performance stand-point.

Data Analytics has become very popular on large datasets in different organizations. It is inevitable to use distributed resources such as Clouds for Data Analytics and other types of data processing at larger scales. To effectively utilize all system resources, an efficient scheduler is needed, but the traditional resource managers and job schedulers are centralized and designed for larger batch jobs which are fewer in number. Frameworks such as Hadoop and Spark, which are mainly designed for Big Data analytics, have been able to allow for more diversity in job types to some extent. However, even these systems have centralized architectures and will not be able to perform well on large scales and under heavy task loads. Modern applications generate tasks at very high rates that can cause significant slowdowns on these frameworks. Additionally, over-decomposition has shown to be very useful in increasing the system utilization. In order to achieve high efficiency, scalability, and better system utilization, it is critical for a modern scheduler to be able to handle over-decomposition and run highly granular tasks. Further, to achieve high performance, Albatross is written in C/C++, which imposes a minimal overhead to the workload process as compared to languages like Java or Python. We propose Albatross, a task level scheduling and execution framework that uses a Distributed Message Queue (DMQ) for task distribution among its workers. Unlike most scheduling systems, Albatross uses a pulling approach as opposed to the common push approach. The former would let Albatross achieve a good load balancing and scalability. Furthermore, the framework has built in support for task execution dependency on workflows. Therefore, Albatross is able to run various types of workloads, including Data Analytics and HPC applications. Finally, Albatross provides data locality support. This allows the framework to achieve higher performance through minimizing the amount of unnecessary data movement on the network. Our evaluations show that Albatross outperforms Spark and Hadoop at larger scales and in the case of running higher granularity workloads.

In this paper we introduce M-PLAT, an intelligent tutoring system for helping students to learn the basics of programming languages. In fact, the M-PLAT system represents a full collection of intelligent tutoring systems, and due to its modular and hierarchical architecture it can be upgraded to deal with a new programming language that is not yet included in the system. Thus, this tutoring system is not limited to a unique programming language, making M-PLAT a very scalable system. The best important feature of our system is that M-PLAT dynamically adapts itself to the learning style of each student, optimizing the learning time to each student.

Fast Iterative Method in Solving Eikonal Equations: A Multi-level Parallel Approach

In spite of the attractiveness of video-on-demand (VoD) services, their implementation up to the present has not been as widespread as could have been desired, due to centralized VoD systems having a limited streaming capacity and poor scaling. One-level proxy-based systems have been proposed to increase system capacity, but their scalability is still limited by the main net bandwidth. To achieve a scalable large-scale system (LVoD), we propose a hierarchical architecture, called double P-tree, based on a tree topology of independent local nets with proxies. To decentralize the architecture and facilitate the system's growth, the functionality of the proxy has been modified in such a way that it works at the same time as caching for the most-watched videos, and as a distributed mirror for the remaining videos. Moreover, the double P-tree topology interconnects local networks in order to improve connectivity and efficiency. The evaluation of this new architecture, through an analytical model, shows that the double P-tree architecture is a good approach to the design of flexible LVoD systems, without the need for using a complex server or high-bandwidth networks.

We present a hybrid approach to generate plausible motions for high-DOF human-like articulated figures in constrained environment with multiple obstacles. The method combines motion planning and motion blending techniques to efficiently produce natural and collision-free human motion for different tasks.

Efficient mapping of a real-time HD video application to graphics hardware is challenging. Developers face the challenges of choosing the right parallelism model, balancing thread's process granularity between massive computing resources on the GPU, and partitioning tasks between the CPU and GPU. The paper illustrated the mapping approaches by a case of HD H.264 encoder based on X264 reference code and then evaluating it on state-of-the-art CPU and GPUs in depth. In the paper, we first split most of the computing task into Single-Instruction Multiple-Thread (SIMT) kernels, which are then chained intocertaininput/output data stream. Then we implementeda completed H.264 encoding on the computer unified device architecture (CUDA) platform. Finally, we present methods for exploiting multi-level parallelism and memory efficiency when mapping H.264 code, which we use to increase the efficiency of the execution on GPUs. Our experimental results show that computation efficiency of GPU and then real-time encoding performance are achieved with CUDA.