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.

Java-centric distributed computing

Abstract: The Java language and platform provide a base for distributed computing that changes several conventional assumptions. In particular, the Java Virtual Machine allows a group of Java-enabled machines to be treated as a homogeneous group rather than a heterogeneous group, despite possible differences in the machine architectures and underlying operating systems. Java also makes it possible to safely and dynamically load code in a running Java process. Together, these features allow a system to invoke methods on remote objects, which can move code associated with language-level objects from the calling process to the process called and vice versa. Combining these qualities with a language-centric design not only significantly simplifies traditional RPC systems, it adds functionality that was previously not possible. We designed Java Remote Method Invocation (RMI) to support pure-Java distributed objects in a seamless manner. RMI allows calls to be made between Java objects in different virtual machines, even on different physical machines.

A standard audit trail format

Abstract: The central role of audit trails, or (more properly) logs, in security monitoring needs little description, for it is too well known for any to doubt it. Auditing, or the analysis of logs, is a central part of security not only in computer system security but also in analyzing financial and other non-technical systems. As part of this process, it is often necessary to reconcile logs from different sources. This speaks of a need for a standard logging format. A standard log format robust enough to meet the needs of heterogeneity, transportability across various network protocols, and flexibility sufficient to meet a variety of needs in very different environments must satisfy two basic properties: extensibility and portability. This report presents the author`s proposed format for a standard log record. In section 3, he shows how and where the translation should be done, and in section 4 he demonstrates how log records from several disparate systems would be put into this format. Section 5 concludes with some observations and suggestions for future work.

Application restructuring and performance portability on shared virtual memory and hardware-coherent multiprocessors

Abstract: The performance portability of parallel programs across a wide range of emerging coherent shared address space systems is not well understood Programs that run well on efficient, hardware cache-coherent systems often do not perform well on less optimal or more commodity-based communication architectures This paper studies this issue of performance portability, with the commodity communication architecture of interest being page-grained shared virtual memory We begin with applications that perform well on moderat scale hardware cache-coherent systems, and find that they do not do so well on SVM systems Then, we examine whether and how the applications can be improved for SVM systems --- through data structuring or algorithmic enhancements---and the nature and difficulty of the optimization Finally, we examine the impact of the successful optimizations on hardware-coherent platforms themselves, to see whether they are helpful, harmful or neutral on those platforms We develop a systematic methodology to explore optimizations in different structured classes The results, and the difficulty of the optimizations, lead insight not only into performance portability but also into the viability of SVM as a platform for these types of applications

Implementation of a BIM Domain-specific Language for the Building Environment Rule and Analysis

Abstract: This paper describes an implementation process for a domain-specific computer programming language: the Building Environment Rule and Analysis (BERA) Language. As the growing area of Building Information Modeling (BIM), there has been a need to develop highly customized domain-specific languages for handling issues in building models in the architecture, engineering and construction (AEC) industry sector. The BERA Language, one of the domain-specific languages, deals with building information models in an intuitive way in order to ensure the quality of design and assess the design programming requirements using user-defined rules in the early design phases. To accomplish these goals, the BERA Language provides the capabilities for an effectiveness and ease of use without precise knowledge of general-purpose languages that are conventionally used in BIM software development. Furthermore, the design and implementation of the BERA Language focuses on building objects and their associated information-rich properties and relationships. This paper represents the implementation issues of the BERA Language associated with the building information models, their mapping into the building data structure, and their instantiation and execution. In addition, Portability of the language, extensibility and platform-dependent issues are involved in the BERA Language implementation. The implementation described in this paper is based on the use of Industry Foundation Classes (IFC) as given building information models, Solibri Model Checker?${\circledR }$ (SMC) as an IFC engine, and the Java Virtual Machine (JVM) as a compilation and execution environment.

No-Execute-After-Read: Preventing Code Disclosure in Commodity Software

Abstract: Memory disclosure vulnerabilities enable an adversary to successfully mount arbitrary code execution attacks against applications via so-called just-in-time code reuse attacks, even when those applications are fortified with fine-grained address space layout randomization. This attack paradigm requires the adversary to first read the contents of randomized application code, then construct a code reuse payload using that knowledge. In this paper, we show that the recently proposed Execute-no-Read (XnR) technique fails to prevent just-in-time code reuse attacks. Next, we introduce the design and implementation of a novel memory permission primitive, dubbed No-Execute-After-Read (near), that foregoes the problems of XnR and provides strong security guarantees against just-in-time attacks in commodity binaries. Specifically, near allows all code to be disclosed, but prevents any disclosed code from subsequently being executed, thus thwarting just-in-time code reuse. At the same time, commodity binaries with mixed code and data regions still operate correctly, as legitimate data is still readable. To demonstrate the practicality and portability of our approach we implemented prototypes for both Linux and Android on the ARMv8 architecture, as well as a prototype that protects unmodified Microsoft Windows executables and dynamically linked libraries. In addition, our evaluation on the SPEC2006 benchmark demonstrates that our prototype has negligible runtime overhead, making it suitable for practical deployment.