Abstract
The aim of this work is to measure the impact of aspect-oriented programming on software performance. Thus, we hypothesized as follow: adding aspects to a base program will affect its performance because of the overhead caused by the control flow switching, and that incremental effect on performance is more obvious as the number of join points increases. To test our hypotheses we carried out a case study of two concurrent architectures: Half-Sync/Half-Async and Leader/Followers. Aspects are extracted and encapsulated and the base program performance was compared to the aspect program. Our results show that the aspect-oriented approach does not have significant effect on the performance and that in some cases an aspect-oriented program even outperforms the non-aspect program. We also investigated the effect of cache fault rate on performance for both aspect and non-aspect programs. Based on our experiments, the results demonstrate that there is a close correlation between the cache fault rate and performance, which may be in favor of aspect code if some aspects are frequently accessed. Additionally, the introduction of a large number of join points does not have significant effect on performance.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
References
Aoki, Y., & Chiba, S. (2007). Performance improvement for persistent systems by AOP. Proc. of the Software-Engineering Properties of Languages and Aspect Technologies (SPLAT).
Apel, S., & Batory, D. (2008). How AspectJ is used: An analysis of eleven AspectJ programs, Technical report MIP-0801. Passau: Universität Passau.
Apel, S., Kästner, C., Batory, D. (2008). Program refactoring using functional aspects. Proc. of the 7 th International Conference on Generative Programming and Component Engineering.
AspectJ. Crosscutting objects for better modularity. http://www.eclipse.org/aspectj/index.php. Accessed 10 Jun 2010.
Black, S. Design patterns: Layers. http://stevenblack.com/PTN-Layers.html. Accessed 16 Jul 2010.
Cunha, C.A., Sobral, J. L., Monteiro, Monteiro, M.P. (2006). Reusable aspect-oriented implementations of concurrency control patterns and mechanisms. Proc. of the Aspect-Oriented Software Development (pp. 134–145).
Goetz, B., Peierls, T., Bloch, J., Bowbeer, J., Holmes, D., & Lea, D. (2006). Java concurrency in practice. Boston: Addison Wesley Professional.
Kersten, M. (2005). AOP@Work: AOP tools comparision, Part1. IBM, http://www.ibm.com/developerworks/java/library/j-aopwork1/. Accessed 10 Jun 2010.
Kiczales, G. (1997). Aspect-oriented programming. Proc of the European Conference on Object-Oriented Programming (ECOOP).
Kim, C.H.P., Czarnecki, K., Batory, D. (2008). On-demand materialization of aspects for application development. Proc. of the Software-Engineering Properties of Languages and Aspect Technologies (SPLAT), pp. 1–6.
Liu, W.-L., Lung, C.-H., Ajila, S. (2011). Impact of aspect orientation on software performance: A case study of leader/followers and Half-Sync/Half-Async architectures. Proc. of the 35 th Annual IEEE Computer Software and Applications Conf. (COMPSAC).
Lung, C.H., Selvarajah, K., Balasubramaniam, B., Elankeswaran, P., Gopalasundaram, U. (2006). Architecture-Centric Software Generation: An experimental study on distributed systems. Proc. of the 5 th International Conference on Generative Programming and Component Engineering.
Microsoft Support (2006) How to manage system monitor counters in windows XP. Microsoft. http://support.microsoft.com/kb/305610. Accessed 30 Jun 2010.
Oaks, A., & Wong, H. (2004). Java threads (3rd ed.). Sebastopol: O’Reilly.
Osogami, T., & Kato, S. (2007). Optimizing system configurations quickly by guessing at the performance. Proc. of 2007 ACM Special Interest Group on Measurement and Evaluation, pp.145–156.
Schmidt, D. C., Stal, M., Rohnert, H., & Bushmann, F. (2000). Pattern-oriented software architecture: Patterns for concurrent and networked objects. Hoboken: John Wiley & Sons.
Subotic, S., & Bishop, J. (2005). Emergent behaviour of aspects in high performance and distributed computing. Proc. of the South African Institute for Computer Scientists and Information Technologists (SAICSIT), pp. 11–19.
Welsh, M., Gribble, S., Brewer, E., Culler, D. (2000). A design framework for highly concurrent systems. Tech. Rep., UC Berkeley.
Zabatta, F., & Ying, K., (1998). Dynamic thread creation: An asynchronous load balancing scheme for parallel searches. Proc. of 10 th International Conference on Parallel and Distributed Computing and Systems.
Zhang, X. (2010). An architecture-based self-adaptive framework for performance and reliability improvement. M.A.Sc. thesis, Carleton University, Ottawa, ON, Canada.
Zhang, Y., Chen, Y., Zhang, J., Wang, Q. (2008) Resolving synchronization and analyzing based on aspect-oriented programming. Proc. of the International Symposium on Computer Science and Computational Technology (ISCSCT), vol. 1, pp. 34–37.
Zhang, J., Chen, Y., Liu, G., & Li, H. (2009a). An aspectual state model and its realization based on AOP. Proc. of the WRI World Congress on Software Engineering, 3, 163–166.
Zhang, Y., Zhang, J., Zhang, D. (2009b). Implementing and testing producer-consumer problem using aspect-oriented programming. Proc. of the 5 th International Conference on Information Assurance and Security, pp.749–752
Author information
Authors and Affiliations
Corresponding author
Appendix
Appendix
Rights and permissions
About this article
Cite this article
Lung, CH., Ajila, S.A. & Liu, WL. Measuring the performance of aspect oriented software: A case study of Leader/Followers and Half-Sync/Half-Async architectures. Inf Syst Front 16, 853–866 (2014). https://doi.org/10.1007/s10796-013-9423-z
Published:
Issue Date:
DOI: https://doi.org/10.1007/s10796-013-9423-z