Software portability

About: Software portability is a research topic. Over the lifetime, 8987 publications have been published within this topic receiving 164922 citations. The topic is also known as: portability.

Understanding Android Fragmentation with Topic Analysis of Vendor-Specific Bugs

Abstract: The fragmentation of the Android ecosystem causes portability and compatibility issues within the entire Android platform, which increases developer workload, delays application deployment, and ultimately disappoints users. This subject is discussed in the press and in scientific publications but it has yet to be systematically examined. The Android bug reports, as submitted by Android-device users, span across operating-system versions and hardware platforms and can provide interesting evidence about the problem. In this paper, we analyze the bug reports related to two popular vendors, HTC and Motorola. First, we manually label the bug reports. Next, we use Labeled-LDA (Latent Dirichlet Allocation) on the labeled data and LDA on the original data, to infer topics. Finally, by examining the relevance of the top 18 bug topics for each vendor's bug reports over time, we classify topics as common or unique (vendor-specific). The latter category constitutes evidence of fragmentation and lack of portability. By comparing Labeled-LDA against LDA, we find that Labeled-LDA produced better, i.e., more feature oriented, topics than LDA. In this paper we find out how fragmentation is manifested within the Android project and we propose a method for tracking fragmentation using feature analysis on project repositories.

Development of a measure to assess the quality of user-developed applications

Abstract: For several years now, software quality has been a major concern for those involved in the area of software engineering, and researchers as well as practitioners of the domain have proposed instruments to measure it. Application quality is also a concern for researchers and managers involved in the area of end-user computing. However, since end-user computing research is in a much earlier stage than research in software engineering, relatively few efforts have been made to assess the quality of user-developed applications. Building on earlier work in software engineering and in end-user computing, this study developed and assessed a measure of user-developed applications quality. The quality construct comprises eight dimensions: reliability, effectiveness, portability, economy, user-friendliness, understandability, verifiability, and maintainability. In turn, each quality dimension is composed of a set of criteria. Finally, each criterion is measured by a series of items. The instrument was tested by means of a survey involving 110 end-users. Confirmatory factor analysis, using the partial least squares technique, was conducted. The results indicate that the 56-items instrument is reliable and valid, and that it may be a useful tool for researchers and for practitioners alike.

RAJA: Portable Performance for Large-Scale Scientific Applications

Abstract: Modern high-performance computing systems are diverse, with hardware designs ranging from homogeneous multi- core CPUs to GPU or FPGA accelerated systems. Achieving desir- able application performance often requires choosing a program- ming model best suited to a particular platform. For large codes used daily in production that are under continual development, architecture-specific ports are untenable. Maintainability re- quires single-source application code that is performance portable across a range of architectures and programming models. In this paper we describe RAJA, a portability layer that enables C++ applications to leverage various programming models, and thus architectures, with a single-source codebase. We describe preliminary results using RAJA in three large production codes at Lawrence Livermore National Laboratory, observing 17×, 13× and 12× speedup on GPU-only over CPU- only nodes with single-source application code in each case.

Method and system for the specification of interface definitions and business rules and automatic generation of message validation and transformation software

Abstract: This system for generating message transformation and validation software uses interface definition documents as inputs. An interface definition consists of an internally consistent set of message definitions, data dictionary entries, transformation rules, and validation rules. A user-friendly graphical user interface provides the requirements engineer or other user with the ability to specify these documents. This graphical user interface is a structured table and rules editor that allows the requirements engineer to enter and validate interface definitions to ensure that the definitions meet certain predetermined requirements. The generation system takes the interface definition documents as input and generates various software artifacts to transform and validate messages. W3C XML schemas are generated from an interface definition for assistance with code development, for use as standards-compliant interface definition that can be reused and composed with other schemas, and for validating messages. Extensible Stylesheet Language Transform files are generated from an interface definition to transform and validate messages. These generated software artifacts for message transformation and validation may then be used to implement message-processing systems. One example where this software was deployed is a wireless or local number portability service bureau that permits portability requests to pass from one telecommunications entity to another. The graphical user interface also enables the user to compare interface definitions, generate schema artifacts, generate transformation and validation artifacts, generate test cases, generate message indices, and generate documentation for distribution and review (formats include Microsoft Word, rich-text format, and HTML). Preexisting requirements documents may be converted for use in the present system by parsing and translating the preexisting documents into the interface definition documents. After this conversion process, information that could not be parsed and translated is referred to the requirements engineer or other user, who reenters the information using the structured table and rules editor.

Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code

Abstract: Computers have become increasingly complex with the emergence of heterogeneous hardware combining multicore CPUs and GPUs. These parallel systems exhibit tremendous computational power at the cost of increased programming effort resulting in a tension between performance and code portability. Typically, code is either tuned in a low-level imperative language using hardware-specific optimizations to achieve maximum performance or is written in a high-level, possibly functional, language to achieve portability at the expense of performance. We propose a novel approach aiming to combine high-level programming, code portability, and high-performance. Starting from a high-level functional expression we apply a simple set of rewrite rules to transform it into a low-level functional representation, close to the OpenCL programming model, from which OpenCL code is generated. Our rewrite rules define a space of possible implementations which we automatically explore to generate hardware-specific OpenCL implementations. We formalize our system with a core dependently-typed lambda-calculus along with a denotational semantics which we use to prove the correctness of the rewrite rules. We test our design in practice by implementing a compiler which generates high performance imperative OpenCL code. Our experiments show that we can automatically derive hardware-specific implementations from simple functional high-level algorithmic expressions offering performance on a par with highly tuned code for multicore CPUs and GPUs written by experts.