Debugging System for Programs with Different Execution Models
Abstract
This article is devoted to the issues of debugging programs in modern high-level languages. There are many different languages with different paradigms and different execution models. Each of them needs an instrument to analyze a program during its execution. For most programming languages, there are debugging tools that provide this capability, but debugging a program that consists of several parts in different programming languages is very difficult.
The article contains an analysis of the tools for debugging programs for various programming languages. We provide the minimum requirements for the debugger and describe the main approaches to the implementation of debuggers for basic computation models - compilation, interpretation and dynamic compilation. The drawbacks of using existing tools for debugging programs that combine two different computation models are identified. As a solution, we propose a system that allows us to debug such programs by combining the capabilities of the debuggers for each of the languages. The software implementation of the described system for debugging programs combining the C # and C ++ languages has been developed. The debugger interaction protocol underlying the system does not depend on the implementation of its components and can be used for other combinations of languages.
References
[2] Dimpsey R., Arora R., Kuiper K. Java server performance: a case study of building efficient, scalable Jvms. IBM Systems Journal. 2000; 39(1):151-174. (In Eng.) DOI: https://doi.org/10.1147/sj.391.0151
[3] Kotzmann T., Wimmer C., Mössenböck H., Rodriguez T., Russell K., Cox D. Design of the Java HotSpot™ client compiler for Java 6. ACM Transactions on Architecture and Code Optimization. 2008; 5(1):1-32. (In Eng.) DOI: https://doi.org/10.1145/1369396.1370017
[4] Everett G.D., McLeod Jr.R. Software Testing: Testing Across the Entire Software Development Life Cycle. John Wiley & Sons; 2007. (In Eng.)
[5] Veeraraghavan K., Lee D., Wester B., Ouyang J., Chen P.M., Flinn J., Narayanasamy S. DoublePlay: Parallelizing Sequential Logging and Replay. ACM Transactions on Computer Systems. 2012; 30(1):1-24. (In Eng.) DOI: https://doi.org/10.1145/2110356.2110359
[6] Elsaka E. Fault Localization Using Hybrid Static/Dynamic Analysis. Advances in Computers. 2017; 105:79-114. (In Eng.) DOI: https://doi.org/10.1016/bs.adcom.2016.12.004
[7] Huang T.-Y., Chou P.-C., Tsai C.-H., Chen H.-A. Automated fault localization with statistically suspicious program states. In: Proceedings of the 2007 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems (LCTES'07). Association for Computing Machinery, New York, NY, USA; 2007. p. 11-20. (In Eng.) DOI: https://doi.org/10.1145/1254766.1254769
[8] Debroy V., Wong W.E. Combining mutation and fault localization for automated program debugging. Journal of Systems and Software. 2014; 90:45-60. (In Eng.) DOI: https://doi.org/10.1016/j.jss.2013.10.042
[9] Ungar D., Lieberman H., Fry C. Debugging and the experience of immediacy. Communications of the ACM. 1997; 40(4):38-43. (In Eng.) DOI: https://doi.org/10.1145/248448.248457
[10] Lawrance J., Bogart C., Burnett M., Bellamy R., Rector K., Fleming S.D. How Programmers Debug, Revisited: An Information Foraging Theory Perspective. IEEE Transactions on Software Engineering. 2010; 39(2):197-215. (In Eng.) DOI: https://doi.org/10.1109/TSE.2010.111
[11] Spinellis D. Modern debugging: the art of finding a needle in a haystack. Communications of the ACM. 2018; 61(11): 124-134. (In Eng.) DOI: https://doi.org/10.1145/3186278
[12] Layman L., Diep M., Nagappan M., Singer J., Deline R., Venolia G. Debugging Revisited: Toward Understanding the Debugging Needs of Contemporary Software Developers. In: 2013 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. Baltimore, MD; 2013. p. 383-392. (In Eng.) DOI: https://doi.org/10.1109/ESEM.2013.43
[13] Parson D., Murray D.J., Chen Y. Object-oriented design patterns for debugging heterogeneous languages and virtual machines. Software: Practice and Experience. 2005; 35(3):255-279. (In Eng.) DOI: https://doi.org/10.1002/spe.634
[14] Tanenbaum A.S., Bos H. Modern Operating Systems. 4th Edition, Pearson; 2015. (In Eng.)
[15] Padala P. Playing with ptrace. Part I. Linux Journal. 2002; 2002(103):5. (In Eng.)
[16] Cifuentes C., Gough K.J. Decompilation of binary programs. Software - Practice & Experience. 1995; 25(7):811-829. (In Eng.) DOI: https://doi.org/10.1002/spe.4380250706
[17] Li Y., Ding Sh., Zhang Q., Italiano D. Debug information validation for optimized code. In: Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2020). Association for Computing Machinery, New York, NY, USA; 2020. p. 1052-1065. (In Eng.) DOI: https://doi.org/10.1145/3385412.3386020
[18] Eager M.J., Consulting E. Introduction to the DWARF Debugging Format. Group; 2007. (In Eng.)
[19] Pagan F.G. On Interpreter-Oriented Definitions of Programming Languages. The Computer Journal. 1976; 19(2):151-155. (In Eng.) DOI: https://doi.org/10.1093/comjnl/19.2.151
[20] Romer T.H., Lee D., Voelker G.M., Wolman A., Wong W.A., Baer J.-L., Bershad B.N., Levy H.M. The structure and performance of interpreters. ACM SIGPLAN Notices. 1996; 31(9):150-159. (In Eng.) DOI: https://doi.org/10.1145/248209.237175
[21] Chow F. Intermediate Representation: The increasing significance of intermediate representations in compilers. Queue. 2013; 11(10):30-37. (In Eng.) DOI: https://doi.org/10.1145/2542661.2544374
[22] Aycock J. A brief history of just-in-time. ACM Computing Surveys. 2003; 35(2):97-113. (In Eng.) DOI: https://doi.org/10.1145/857076.857077
[23] Kulkarni P.A. JIT compilation policy for modern machines. In: Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications (OOPSLA'11). Association for Computing Machinery, New York, NY, USA; 2011. p. 773-788. (In Eng.) DOI: https://doi.org/10.1145/2048066.2048126
[24] Rogov S.V., Kirillin V.A., Sidelnikov V.V. Optimization of Java Virtual Machine with Safe-Point Garbage Collection. In: 2006 IEEE International Symposium on Consumer Electronics. St. Petersburg; 2006. p. 1-5. (In Eng.) DOI: https://doi.org/10.1109/ISCE.2006.1689453
[25] Bishop J., Horspool R.N., Worrall B. Experience in integrating Java with C# and .NET. Concurrency and Computation: Practice & Experience. Special Issue: 2002 ACM Java Grande–ISCOPE Conference Part I. 2005; 17(5-6):663-680. (In Eng.) DOI: https://doi.org/10.1002/cpe.858
[26] Soldatov A., Balykov G., Zhukov A., Shapovalova E., Pavlov E. .NET Runtime and Tools for Tizen Operating System. In: Ivanov V., Kruglov A., Masyagin S., Sillitti A., Succi G. (ed.) Open Source Systems. OSS 2020. IFIP Advances in Information and Communication Technology. 2020; 582: 190-195. Springer, Cham. (In Eng.) DOI: https://doi.org/10.1007/978-3-030-47240-5_19
This work is licensed under a Creative Commons Attribution 4.0 International License.
Publication policy of the journal is based on traditional ethical principles of the Russian scientific periodicals and is built in terms of ethical norms of editors and publishers work stated in Code of Conduct and Best Practice Guidelines for Journal Editors and Code of Conduct for Journal Publishers, developed by the Committee on Publication Ethics (COPE). In the course of publishing editorial board of the journal is led by international rules for copyright protection, statutory regulations of the Russian Federation as well as international standards of publishing.
Authors publishing articles in this journal agree to the following: They retain copyright and grant the journal right of first publication of the work, which is automatically licensed under the Creative Commons Attribution License (CC BY license). Users can use, reuse and build upon the material published in this journal provided that such uses are fully attributed.
