We present a modular approach to implementing dynamic algorithm switching for parallel scientific simulations. Our approach leverages modem software engineering techniques to implement fine-grained control of algorith...
详细信息
We present a modular approach to implementing dynamic algorithm switching for parallel scientific simulations. Our approach leverages modem software engineering techniques to implement fine-grained control of algorithmic behavior in scientific simulations as well as to improve modularity in realizing the algorithm switching functionality onto existing application source code. Through fine-grained control of functional behavior in an application, our approach enables design and implementation of application specific dynamic algorithm switching scenarios. To ensure modularity, our approach considers dynamic algorithm switching as a separate concern with regard to a given application and encourages separate development and transparent integration of the switching functionality without directly modifying the original application code. By applying and evaluating our approach with a real-world scientific application to switch its simulation algorithms dynamically, we demonstrate the applicability and effectiveness of our approach to constructing efficient parallel simulations.
Many profilers for virtual execution environments, such as the Java virtual machine (JVM), are implemented with low-level bytecode instrumentation techniques, which is tedious, error-prone, and complicates maintenance...
详细信息
Many profilers for virtual execution environments, such as the Java virtual machine (JVM), are implemented with low-level bytecode instrumentation techniques, which is tedious, error-prone, and complicates maintenance and extension of the tools. In order to reduce the development time and cost, we promote building profilers for the JVM using high-level aspect-oriented programming (AOP). We show that the use of aspects yields concise profilers that are easy to develop, extend, and maintain, because low-level instrumentation details are hidden from the tool developer. In order to build efficient profilers, we introduce inter-advice communication, an extension to common AOP languages that enables efficient data passing between advices that are woven into the same method using local variables. We illustrate our approach with two case studies. First, we show that an existing, instrumentation-based tool for listener latency profiling can be easily recast as an aspect. Second, we present an aspect for comprehensive calling context profiling. In order to reduce profiling overhead, our aspect parallelizes application execution and profile creation, resulting in a speedup of 110% on a machine with more than two cores, compared with a primitive, non-parallel approach. Copyright (C) 2011 John Wiley & Sons, Ltd.
In a distributed system, programs interact with each other to achieve its functionality. To build a robust system, developers should care about exception handling. This paper propose a dynamic analysis method to explo...
详细信息
ISBN:
(纸本)9781538614457
In a distributed system, programs interact with each other to achieve its functionality. To build a robust system, developers should care about exception handling. This paper propose a dynamic analysis method to explore exception handling strategies of a third-party library without looking code. In result section, we explore an operation which connects to a MySQL server.
An aspect-oriented programming (AOP) based approach is proposed to perform context-aware service composition on the fly. It realises context-aware composition by semantically weaving context into Web service compositi...
详细信息
An aspect-oriented programming (AOP) based approach is proposed to perform context-aware service composition on the fly. It realises context-aware composition by semantically weaving context into Web service composition. The context weaver algorithm is implemented and illustrated. The proposed semantic weaving allows Web services to be composed as the context changes. (C) 2010 Elsevier B.V. All rights reserved.
aspect-oriented programming (AOP) is commonly assumed to be a technique which improves the resulting software with respect to modularity. However, previous empirical experiments suggest that AOP is with respect to dev...
详细信息
ISBN:
(纸本)9780769543987
aspect-oriented programming (AOP) is commonly assumed to be a technique which improves the resulting software with respect to modularity. However, previous empirical experiments suggest that AOP is with respect to development or maintenance time either a technique without a measurable benefit or a technique with a measurable negative effect. A possible reason why previous experiments were not able to show such a benefit is, that those experiments did not consider situations where AOP has its strength: situations where modules need to be frequently changed. In those situations AOP might be able to compensate a possible higher initial development effort. This paper describes an empirical, socio-technical study with Java and aspectJ where developers needed to perform changes on their code base multiple times. It shows that frequent changes in the crosscutting code which do not change the concern's underlying structure compensate an initial higher development time for those concerns. But it also shows that changes, which do alter the concern's structure again result in higher development times when using AOP.
aspect-oriented programming (AOP) is a programmatic methodology to handle better modularized code by separating crosscutting concerns from the traditional abstraction boundaries. Automated testing, as one of the most ...
详细信息
aspect-oriented programming (AOP) is a programmatic methodology to handle better modularized code by separating crosscutting concerns from the traditional abstraction boundaries. Automated testing, as one of the most demanding needs of the software development to reduce both human effort and costs, is a delicate issue in testing aspect-oriented programs. Prior studies in the automated test generation for aspect-oriented programs have been very limited with respect to the need for both adequate tool support and capability concerning effectiveness and efficiency. This paper describes a new AOP-specific tool for testing aspect-oriented programs, called RAMBUTANS. The RAMBUTANS tool uses a directed random testing technique that is especially well suited for generating tests for aspectual features in aspectJ. The directed random aspect of the tool is parameterized by associating weights to aspects, advice, methods, and classes by controlling object and joint point creations during the test generation process. We present a comprehensive empirical evaluation of our tool against the current AOP test generation approaches on three industrial aspect-oriented projects. The results of the experimental and statistical tests showed that RAMBUTANS tool produces test suites that have higher fault-detection capability and efficiency for aspectJ-like programs.
In the maintenance of software applications, database evolution is one common difficulty. In object-oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require signi...
详细信息
In the maintenance of software applications, database evolution is one common difficulty. In object-oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect-oriented programming to support semi-transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect-oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer. Copyright (c) 2016 John Wiley & Sons, Ltd.
This paper presents a dynamic parallel context-sensitive slicing algorithm for distributed AOPs. The context sensitivity makes the computed slice more precise and accurate. We introduce parallelism in our algorithm to...
详细信息
This paper presents a dynamic parallel context-sensitive slicing algorithm for distributed AOPs. The context sensitivity makes the computed slice more precise and accurate. We introduce parallelism in our algorithm to make slice computation faster. We have developed a tool called D-aspectJ slider to compute dynaMic slices for distributed AOPs. The proposed slicing technique is compared with two other related existing techniques using ten case studies. The experimentation shows that our proposed slicing algorithm generates smaller slices in less time as compared to other two existing algorithms.
Recent studies indicate that transient memory errors (soft errors) have become a relevant source of system failures. This paper presents a generic software-based fault-tolerance mechanism that transparently recovers f...
详细信息
Recent studies indicate that transient memory errors (soft errors) have become a relevant source of system failures. This paper presents a generic software-based fault-tolerance mechanism that transparently recovers from memory errors in object-oriented program data structures. The main benefits are the flexibility to choose from an extensible toolbox of easily pluggable error detection and correction schemes, such as Hamming and CRC codes. This is achieved by a combination of aspect-oriented and generative programming techniques. Furthermore, we present a wait-free synchronization algorithm for error detection in data structures that are used concurrently by multiple threads of control. We give a formal correctness proof and show the excellent scalability of our approach in a multiprocessor environment. In a case study, we present our experiences with selectively hardening the eCos operating system and its benchmark suite. We explore the trade-off between resiliency and performance by choosing only the most vulnerable data structures for error recovery. Thereby, the total number of system failures, manifesting as silent data corruptions and crashes, is reduced by 69.14 percent at a negligible runtime overhead of 0.36 percent.
暂无评论