Showing papers on "Software portability published in 2013"

How, and why, process metrics are better

Abstract: Defect prediction techniques could potentially help us to focus quality-assurance efforts on the most defect-prone files. Modern statistical tools make it very easy to quickly build and deploy prediction models. Software metrics are at the heart of prediction models; understanding how and especially why different types of metrics are effective is very important for successful model deployment. In this paper we analyze the applicability and efficacy of process and code metrics from several different perspectives. We build many prediction models across 85 releases of 12 large open source projects to address the performance, stability, portability and stasis of different sets of metrics. Our results suggest that code metrics, despite widespread use in the defect prediction literature, are generally less useful than process metrics for prediction. Second, we find that code metrics have high stasis; they don't change very much from release to release. This leads to stagnation in the prediction models, leading to the same files being repeatedly predicted as defective; unfortunately, these recurringly defective files turn out to be comparatively less defect-dense.

Survey, comparison and evaluation of cross platform mobile application development tools

Abstract: Mobile application development is becoming more challenging with diverse platforms and their software development kits. In order to reduce the cost of development and reach out to maximum users across several platforms, developers are migrating to cross platform application development tools. In this paper, we provide several decision criteria beyond the portability concerns for choosing suitable cross platform tool for application development. The desirable requirements in a cross platform framework are identified. A general architecture for cross platform application development is discussed. Then a survey of several write once run anywhere tools (PhoneGap, Titanium, Sencha Touch) are provided along with a classification and comparison among the tools. To examine the performance in terms of CPU, memory usage, power consumption, Android test applications are developed using such tools. It is found that PhoneGap consumes less memory, CPU and power since it does not included dedicated UI components. Finally the paper summarizes the contributions and concludes with some future directions.

Terra: a multi-stage language for high-performance computing

Abstract: High-performance computing applications, such as auto-tuners and domain-specific languages, rely on generative programming techniques to achieve high performance and portability. However, these systems are often implemented in multiple disparate languages and perform code generation in a separate process from program execution, making certain optimizations difficult to engineer. We leverage a popular scripting language, Lua, to stage the execution of a novel low-level language, Terra. Users can implement optimizations in the high-level language, and use built-in constructs to generate and execute high-performance Terra code. To simplify meta-programming, Lua and Terra share the same lexical environment, but, to ensure performance, Terra code can execute independently of Lua's runtime. We evaluate our design by reimplementing existing multi-language systems entirely in Terra. Our Terra-based auto-tuner for BLAS routines performs within 20% of ATLAS, and our DSL for stencil computations runs 2.3x faster than hand-written C.

Does size matter?: investigating the impact of mobile phone screen size on users' perceived usability, effectiveness and efficiency.

Abstract: Given the wide adoption of smartphones, an interesting debate is taking place regarding their optimal screen size and specifically whether possible portability issues counterbalance the obvious benefits of a larger screen. Moreover, the lack of scientific evidence about the concrete impact of mobile phones' screen size on usability raises questions both to practitioners and researchers. In this paper, we investigate the impact of a mobile phone's screen size on users' effectiveness, efficiency and perceived usability as measured using System Usability Scale (SUS). An experiment was conducted with 60 participants, which interacted with the same information seeking application on three different devices of the same brand that differed on their screen size. A significant effect of screen size on efficiency was derived, leading to an important finding that users who interact with larger than 4.3in screens are more efficient during information seeking tasks.

Orcc: multimedia development made easy

Abstract: In this paper, we present Orcc, an open-source development environment that aims at enhancing multimedia development by offering all the advantages of dataflow programming: flexibility, portability and scalability. To do so, Orcc embeds two rich eclipse-based editors that provide an easy writing of dataflow applications, a simulator that allows quick validation of the written code, and a multi-target compiler that is able to translate any dataflow program, written in the RVC-CAL language, into an equivalent description in both hardware and software languages. Orcc has already been used to successfully write tens of multimedia applications, such as a video decoder supporting the new High Efficiency Video Coding standard, that clearly demonstrates the ability of the environment to develop complex applications. Moreover, results show scalable performances on multi-core platforms and achieve real-time decoding frame-rate on HD sequences.

A large-scale cross-architecture evaluation of thread-coarsening

Abstract: OpenCL has become the de-facto data parallel programming model for parallel devices in today's high-performance supercomputers. OpenCL was designed with the goal of guaranteeing program portability across hardware from different vendors. However, achieving good performance is hard, requiring manual tuning of the program and expert knowledge of each target device. In this paper we consider a data parallel compiler transformation --- thread-coarsening --- and evaluate its effects across a range of devices by developing a source-to-source OpenCL compiler based on LLVM. We thoroughly evaluate this transformation on 17 benchmarks and five platforms with different coarsening parameters giving over 43,000 different experiments. We achieve speedups over 9x on individual applications and average speedups ranging from 1.15x on the Nvidia Kepler GPU to 1.50x on the AMD Cypress GPU. Finally, we use statistical regression to analyse and explain program performance in terms of hardware-based performance counters.

Smart Grid Infrastructure Using a Hybrid Network Architecture

Abstract: Smart grid can be defined as a modern electric power grid infrastructure for improved efficiency, reliability and safety, with smooth integration of renewable and alternative energy sources through automated control and modern communications technologies. The increase need for more effective power electrical systems control turned the development of smart grids, the main object of study for many researchers. This paper proposes a digital system for condition monitoring, diagnosis and supervisory control applied to smart grids. The system is based on hybrid network architecture (HNA), consisting of a wired infrastructure, a wireless sensor network (WSN), a power line communications (PLC) and a controller area network (CAN). The system is based on three hardware topologies: remote data acquisition units (RDAUs), intelligent sensors modules (ISMs) and a PLC modem. The basic characteristics are: a) easy/low cost implementation, b) easy to set up by user, c) easy implementation of redundant routines (security), d) portability/versatility, and e) open system. To validate the developed system, it was implanted in one underground electric substation power distribution, characterized as an extremely hostile environment for supervisory control applications. In this application, the main challenge is to establish a communication system installed inside the substation with the outside (operations center-OC) considering that there are not commercial solutions appropriate to solve completely this problem.

Kokkos: Enabling Performance Portability Across Manycore Architectures

Abstract: The manycore revolution in computational hardware can be characterized by increasing thread counts, decreasing memory per thread, and architecture specific performance constraints for memory access patterns. High performance computing (HPC) on emerging many core architectures requires codes to exploit every opportunity for thread-level parallelism and satisfy conflicting performance constraints. We developed the Kokkos C++ library to provide scientific and engineering codes with a user accessible many core performance portable programming model. The two foundational abstractions of Kokkos are (1) dispatch work to a many core device for parallel execution and (2) manage multidimensional arrays with polymorphic layouts. The integration of these abstractions enables users' code to satisfy multiple architecture specific memory access pattern performance constraints without having to modify their source code. In this paper we describe the Kokkos abstractions, summarize its application programmer interface (API), and present performance results for a molecular dynamics computational kernel and finite element mini-application.

Asgard: A portable architecture for multilingual dialogue systems

Abstract: Spoken dialogue systems have been studied for years, yet portability is still one of the biggest challenges in terms of language extensibility, domain scalability, and platform compatibility. In this work, we investigate the portability issue from the language understanding perspective and present the Asgard architecture, a CRF-based (Conditional Random Fields) and crowd-sourcing-centered framework, which supports expert-free development of multilingual dialogue systems and seamless deployment to mobile platforms. Combinations of linguistic and statistical features are employed for multilingual semantic understanding, such as n-grams, tokenization and part-of-speech. English and Mandarin systems in various domains (movie, flight and restaurant) are implemented with the proposed framework and ported to mobile platforms as well, which sheds lights on large-scale speech App development.

OmniDB: towards portable and efficient query processing on parallel CPU/GPU architectures

Abstract: Driven by the rapid hardware development of parallel CPU/GPU architectures, we have witnessed emerging relational query processing techniques and implementations on those parallel architectures. However, most of those implementations are not portable across different architectures, because they are usually developed from scratch and target at a specific architecture. This paper proposes a kernel-adapter based design (OmniDB), a portable yet efficient query processor on parallel CPU/GPU architectures. OmniDB attempts to develop an extensible query processing kernel (qKernel) based on an abstract model for parallel architectures, and to leverage an architecture-specific layer (adapter) to make qKernel be aware of the target architecture. The goal of OmniDB is to maximize the common functionality in qKernel so that the development and maintenance efforts for adapters are minimized across different architectures. In this demo, we demonstrate our initial efforts in implementing OmniDB, and present the preliminary results on the portability and efficiency.

The latency, accuracy, and battery (LAB) abstraction: programmer productivity and energy efficiency for continuous mobile context sensing

Abstract: Emerging mobile applications that sense context are poised to delight and entertain us with timely news and events, health tracking, and social connections. Unfortunately, sensing algorithms quickly drain the phone's battery. Developers can overcome battery drain by carefully optimizing context sensing but that makes programming with context arduous and ties applications to current sensing hardware. These types of applications embody a twist on the classic tension between programmer productivity and performance due to their combination of requirements.This paper identifies the latency, accuracy, battery (LAB) abstraction to resolve this tension. We implement and evaluate LAB in a system called Senergy. Developers specify their LAB requirements independent of inference algorithms and sensors. Senergy delivers energy efficient context while meeting the requirements and adapts as hardware changes. We demonstrate LAB's expressiveness by using it to implement 22 context sensing algorithms for four types of context (location, driving, walking, and stationary) and six diverse applications. To demonstrate LAB's energy optimizations, we show often an order of magnitude improvements in energy efficiency on applications compared to prior approaches. This relatively simple, priority based API, may serve as a blueprint for future API design in an increasingly complex design space that must tradeoff latency, accuracy, and efficiency to meet application needs and attain portability across evolving, sensor-rich, heterogeneous, and power constrained hardware.

Improving Performance Portability in OpenCL Programs

Abstract: We study the performance portability of OpenCL across diverse architectures including NVIDIA GPU, Intel Ivy Bridge CPU, and AMD Fusion APU. We present detailed performance analysis at assembly level on three exemplar OpenCL benchmarks: SGEMM, SpMV, and FFT. We also identify a number of tuning knobs that are critical to performance portability, including threads-data mapping, data layout, tiling size, data caching, and operation-specific factors. We further demonstrate that proper tuning could improve the OpenCL portable performance from the current 15% to a potential 67% of the state-of-the-art performance on the Ivy Bridge CPU. Finally, we evaluate the current OpenCL programming model, and propose a list of extensions that improve performance portability.

Cloud4SOA: A Semantic-Interoperability PaaS Solution for Multi-cloud Platform Management and Portability

Abstract: Cloud Platform as a Service (PaaS) is a novel, rapidly growing segment in the Cloud computing market. However, the diversity and heterogeneity of today’s existing PaaS offerings raises several interoperability challenges. This introduces adoption barriers due to the lock-in issues that prevent the portability of data and applications from one PaaS to another, “locking” software developers to the first provider they use. This paper introduces the Cloud4SOA solution, a scalable approach to semantically interconnect heterogeneous PaaS offerings across different Cloud providers that share the same technology. The design of the Cloud4SOA solution, extensively presented in this work, comprises of a set of interlinked collaborating software components and models to provide developers and platform providers with a number of core capabilities: matchmaking, management, monitoring and migration of applications. The paper concludes with the presentation of a proof-of-concept implementation of the Cloud4SOA system based on real-life business scenarios.

Using machine learning to partition streaming programs

Abstract: Stream-based parallel languages are a popular way to express parallelism in modern applications. The efficient mapping of streaming parallelism to today's multicore systems is, however, highly dependent on the program and underlying architecture. We address this by developing a portable and automatic compiler-based approach to partitioning streaming programs using machine learning. Our technique predicts the ideal partition structure for a given streaming application using prior knowledge learned offline. Using the predictor we rapidly search the program space (without executing any code) to generate and select a good partition. We applied this technique to standard StreamIt applications and compared against existing approaches. On a 4-core platform, our approach achieves 60p of the best performance found by iteratively compiling and executing over 3000 different partitions per program. We obtain, on average, a 1.90× speedup over the already tuned partitioning scheme of the StreamIt compiler. When compared against a state-of-the-art analytical, model-based approach, we achieve, on average, a 1.77× performance improvement. By porting our approach to an 8-core platform, we are able to obtain 1.8× improvement over the StreamIt default scheme, demonstrating the portability of our approach.

The FMI++ library: A high-level utility package for FMI for model exchange

Abstract: The success and the advantages of model-based design approaches for complex cyber-physical systems have led to the development of the FMI (Functional Mock-Up Interface), an open interface specification that allows to share dynamic system models between different simulation environments. The FMI specification intentionally provides only the most essential and fundamental functionalities in the form of a C interface. On the one hand, this increases flexibility in use and portability to virtually any platform (even embedded control systems). On the other hand, such a low-level approach implies several prerequisites a simulation tool has to fulfil in order to be able to utilize such an FMI component, for instance the availability of adequate numerical integrators. The FMI++ library presented here addresses this problem for models according to the FMI for Model Exchange by providing high-level functionalities, especially suitable for but not limited to discrete event simulation tools. The capabilities of this approach are illustrated with the help of several applications, where the FMI++ library has been successfully deployed. This approach intends to bridge the gap between the basic FMI specifications and the typical requirements of simulation tools that do not primarily focus on continuous time-based simulation. In other words, this enables such models to be used as de-facto stand-alone co-simulation components.

Enabling advanced environmental conditioning with a building application stack

Abstract: There is enormous potential for building-focused applications to improve operation and sustainability, both for classical uses like modeling or fault detection as well as innovative ones like occupant-driven control or grid-aware energy management. We show that a building application stack - that addresses shortcomings of existing antiquated architectures by democratizing sensor data, constructing a framework for reliable and fault-tolerant operation of concurrent applications, and establishing an application programming interface to promote portability throughout the building stock - enables development of advanced applications. We observe the growing importance of applications that integrate sensors and actuators from the building infrastructure with those from “add-on” networks, and show how this design pattern is further empowered by the architecture. To prove the efficacy of the approach, we implement two advanced environmental conditioning applications on a large, commercial building that was not designed for either of them: a demand-controlled ventilation (DCV) system for balancing air quality considerations and energy use in conference and class room settings and a demand-controlled filtration (DCF) system for conserving recirculating fan energy in an intermittently occupied cleanroom setting. The DCV application is able to reduce air quality threshold violations by over 95% and concurrently reduce ventilation energy consumption by over 80%, while the DCF application can reduce recirculating fan power consumption by half with no repercussions on air quality when the room is occupied. Further, the portability of these applications highlights the potential of the architecture to enable widespread and rapid application development throughout the building stock.

Runtime dependency analysis for loop pipelining in high-level synthesis

Abstract: Research on High-Level Synthesis has mainly focused on applications with statically determinable characteristics and current tools often perform poorly in presence of data-dependent memory accesses. The reason is that they rely on conservative static scheduling strategies, which lead to inefficient implementations. In this work, we propose to address this issue by leveraging well-known techniques used in superscalar processors to perform runtime memory disambiguation. Our approach, implemented as a source-to-source transformation at the C level, demonstrates significant performance improvements for a moderate increase in area while retaining portability among HLS tools.

Investigating applications portability with the Uintah DAG-based runtime system on PetaScale supercomputers

Abstract: Present trends in high performance computing present formidable challenges for applications code using multicore nodes possibly with accelerators and/or co-processors and reduced memory while still attaining scalability. Software frameworks that execute machine-independent applications code using a runtime system that shields users from architectural complexities offer a possible solution. The Uintah framework for example, solves a broad class of large-scale problems on structured adaptive grids using fluid-flow solvers coupled with particle-based solids methods. Uintah executes directed acyclic graphs of computational tasks with a scalable asynchronous and dynamic runtime system for CPU cores and/or accelerators/co-processors on a node. Uintah's clear separation between application and runtime code has led to scalability increases of 1000x without significant changes to application code. This methodology is tested on three leading Top500 machines; OLCF Titan, TACC Stampede and ALCF Mira using three diverse and challenging applications problems. This investigation of scalability with regard to the different processors and communications performance leads to the overall conclusion that the adaptive DAG-based approach provides a very powerful abstraction for solving challenging multi-scale multi-physics engineering problems on some of the largest and most powerful computers available today.

A Systematic Review of Cloud Lock-In Solutions

Abstract: The heterogeneity of cloud semantics, technology and interfaces limits application and platform portability and interoperability, and can easily lead to vendor lock-in. We identify, analyse and classify existing solutions to cloud vendor lock-in, and highlight unresolved challenges. Our survey is based on a systematic review of 721 primary studies that describe the state-of-the-art in managing cloud lock-in, portability and interoperability. 78 of these primary studies were selected and used for a thorough analysis of cloud standards, commercial products and academic work related to cloud lock-in. Our review shows that most solutions proposed so far are platforms, APIs or architectures addressing infrastructure-as-a-service (IaaS) interoperability. From our review, we identify a need for: (i) exploiting established solutions from areas that are closely related to cloud computing, (ii) increasing empirical evidence to raise confidence in existing solutions, and (iii) addressing the socio-technical and business challenges related to cloud lock-in.

Distributed Software Architecture Enabling Peer-to-Peer Communicating Controllers

Abstract: This paper presents a novel model-driven software architecture for systems with high degree of redundancy and modularity of the equipment. The architecture is based on totally decentralized control. It combines adaptability and robustness of multi-agent control architectures with portability and interoperability benefits of IEC 61499 function block architecture. The architecture has been successfully proven feasible on a number of field trials, including modeling and implementation of a medium-scale airport baggage handling control. Deployment was done on distributed networks consisting of configurations ranging from a few to dozens of communicating control nodes. The work confirmed the ability to deliver similar functional characteristics as centralized systems but in a distributed implementation. Performance testing and development verified sufficient performance and software life-cycle benefits.

Semantic and Agnostic Representation of Cloud Patterns for Cloud Interoperability and Portability

Abstract: This paper focuses on two aspects related to the widespread of cloud computing: first, the definition of a common formalism, based on a unique and shared model, which could be used to completely describe Cloud patterns, second, the investigation of a methodology to automatize the recognition of similar elements in Design and Cloud patterns, thus defining an automatic mapping among representations of application that follow these patterns. These aspects are handled on one hand by extending an existing semantic based Design pattern language in order to properly represent both Design and Cloud patterns together with its possible related architectural implementations and on the other hand by using these agnostic representations to define a mapping between Design patterns (a single design pattern or a composition of pattern) and Cloud patterns, in order to obtain a clear model of the cloud applications which could satisfy its original requirements and exploit all the benefits of cloud computing at the same time.