Advanced Debugging Methods

189 Pages·2000·6.488 MB·English

by  Raimondas Lencevicius (auth.)

ADVANCED
DEBUGGING METHODS
THE KLUWER INTERNATIONAL SERIES
IN ENGINEERING AND COMPUTER SCIENCE
ADVANCED
DEBUGGING METHODS
by
Raimondas Lencevicius
Nokia Research Center, U.S.A.
Springer Science+Business Media, LLC
.....
"
SPRINGER SCIENCE+BUSlNESS MEDIA,LLC
Library of Congress Cataloging-in-Publication Data
Lencevicius, Raimondas.
Advanced debugging methods I by Raimondas Lencevicius.
p.cm.--(Kluwer international series in engineering and computer science ; SECS 568)
lncludes bibliographical references and index.
ISBN 978-1-4613-4688-3 ISBN 978-1-4419-8774-7 (eBook)
DOI 10.1007/978-1-4419-8774-7
1. Debugging in computer science. 1. Title. II. Series.
QA76.9.D43 U62000
005.1 '4--dc21
00-055101
Copyright © 2000 by Springer Science+Business Media New York
Originally published by Kluwer Academic Publishers in 2000
Softcover reprint ofthe hardcover lst edition 2000
AII rights reserved. No part of this publication may be reproduced, stored in a retrieval system
or transmitted in any form or by any means, mechanical, photo-copying, recording, or otherwise,
without the prior written permission of the publisher, Springer Science+Business Media, LLC.
Printed on acid-Iree paper.
The Publisher offers discounts on this book for course use and bulk purchases.
For further information, send email to<[email protected]>
CONTENTS
Foreword .................................................................................................................... xi
Preface ............................................ ............................ ......................... .................. xiii
Acknowledgments .................................................................................................... xv
Introduction .................................................................................................. 1
1.1 Outline ................................................................................................... 3
2 Debugging Background and methods .......................................................... 5
2.1 Control Flow Debugging ....................................................................... 6
2.2 Data Observation .................................................................................. 11
2.3 Mixed Constructs ................................................................................ 13
2.4 Program Visualization Systems ........................................................... 15
2.5 Summary ............................................................................................. 16
3 Static Query-Based Debugging .................................................................. 17
3.1 Introduction ......................................................................................... 17
3.2 Query Model ....................................................................................... 18
3.3 Implementation .................................................................................... 26
3.4 Experimental Results ........................................................................... 40
3.5 Related work ....................................................................................... 48
3.6 Summary ............................................................................................. 48
4 Dynamic Query-Based Debugger .............................................................. 49
4.1 Introduction ......................................................................................... 49
4.2 Query Model and Examples ................................................................ 51
4.3 Implementation .................................................................................... 53
4.4 Experimental Results ........................................................................... 70
4.5 Performance Model ............................................................................. 82
4.6 Queries with Changing Results ........................................................... 87
4.7 On-the-fly Debugging ......................................................................... 89
4.8 Related Work ....................................................................................... 95
4.9 Summary ............................................................................................. 98
5 Query Analysis and Classification ........................................................... 101
5.1 Introduction ....................................................................................... 101
5.2 Queries in Software Systems ............................................................. 101
vi
5.3 Query Classification .......................................................................... 121
5.4 Query Analysis and Classification Conclusions ............................... 124
5.5 Summary ........................................................................................... 125
6 Future Work and Open Problems ............................................................. 127
6.1 Automatic Change Sets ..................................................................... 127
6.2 Safe Reevaluation and Distributed Debugging ................................. 131
7 Conclusions .............................................................................................. 137
8 Glossary .................................................................................................... 141
9 References .. ..... ......................................... ................................................ 145
Appendix A Generalized Graph Matching .... ..... ............................................ 161
AppendixB Detailed Data .............................................................................. 165
Index .................................................................................................................. 175
LIST OF FIGURES
Figure 1. Error in javac AST .......................................................................... 2
Figure 2. Error in GUI program ..................................................................... 5
Figure 3. Error in javac AST .......................................................................... 6
Figure 4. Inconsistent list state ..................................................................... 20
Figure 5. Self morphs ................................................................................... 23
Figure 6. Query-based debugger GUI .......................................................... 27
Figure 7. Overview of the query-based debugger ........................................ 28
Figure 8. Data structures of the intermediate form of a query ..................... 28
Figure 9. Query evaluation pseudo-code (beginning) .................................. 29
Figure to. Query evaluation pseudo-code (continued) .................................. 30
Figure 11. Overview of query execution ........................................................ 32
Figure 12. Left-deep join ................................................................................ 34
Figure 13. Hash join ....................................................................................... 37
Figure 14. Incremental delivery pipeline ....................................................... 39
Figure 15. Query execution times .................................................................. 43
Figure 16. Completion time depending on join ordering (small queries) ...... 45
Figure 17. Error in javac AST ........................................................................ 49
Figure 18. Error in molecule simulation ........................................................ 52
Figure 19. Data-flow diagram of dynamic query-based debugger ................. 53
Figure 20. Java program instrumentation ....................................................... 55
Figure 21. Control flow of query execution ................................................... 61
Figure 22. Incremental query evaluation ........................................................ 62
Figure 23. Selection evaluation using custom code ....................................... 64
Figure 24. Modifying a VM to implement LTA. ........................................... 67
Figure 25. Performing LTA with a custom class loader. ............................... 68
Figure 26. Implementing LTA by intercepting system calls .......................... 68
Figure 27. Implementing LTA using dynamic linking ................................... 69
Figure 28. Program slowdown (queries 15-20 not shown) ............................ 75
Figure 29. Breakdown of query overhead as a percentage of total overhead 76
Figure 30. Field assignment frequency in SPECjvm98 ................................. 85
Figure 31. Predicted slowdown ...................................................................... 86
Figure 32. On-the-fly debugging instrumentation .......................................... 90
Figure 33. Inconsistent list state ................................................................... 132
Figure 34. Inconsistent intermediate list state .............................................. 133
Figure 35. Subgraph corresponding to clause Cj in graph G ....................... 162
LIST OF TABLES
Table 1: Sample queries with their input and output sizes ...................: ...... 42
Table 2: Completion time depending on join ordering (large queries) ....... 45
Table 3: Slowdown of nested queries vs. hash queries ............................... 47
Table 4: Response time (time to first result) ............................................... 47
Table 5. Benchmark queries ........................................................................ 71
Table 6. Application sizes and execution times .......................................... 73
Table 7. Overhead of non-incremental evaluation ...................................... 77
Table 8. Benefit of custom selection code (selection queries only) ............ 80
Table 9. Unnecessary assignment test optimization ................................... 81
Table 10. Frequencies and individual evaluation times ................................ 83
Table 11. Maximum field assignment frequencies ....................................... 87
Table 12. Benchmark queries with non-empty results .................................. 88
Table 13. On-the-fly debugging overhead .................................................... 92
Table 14. On-the-fly query overhead ............................................................ 94
Table 15: Query examples .......................................................................... 117
Table 16: Query patterns ............................................................................. 123
Table 17. Field assignment frequency in SPECjvm98 applications ........... 165
Table 18. Breakdown of query overhead .................................................... 168
Table 19. Execution times, overhead times, and invocation frequency ...... 169
Table 20. Results for evaluations with no fast selections and no change tests
. .................................................................................................... 170
Table 21. Non-incremental evaluation results ............................................ 172
Table 22. Predicted slowdown .................................................................... 173
FOREWORD
The growing scale, complexity, and lifetime of software systems
necessitates an approach in which relationships between existing objects and
components can be queried and understood. This book overviews different
debugging approaches and presents a new Query-Based Debugging technique
in which the users ask SQL-like queries on a subset of system classes and the
debugger identifies all objects that currently satisfy the query constraints. The
queries can be asked and their results updated during the execution of the
underlying program.
The main contributions of the book are two-fold. First, it emphasizes
the need for query-based debugging through a number of examples. Second, it
provides an understanding of the obstacles that may arise in the
implementation of such a tool and the classes of queries that can be supported
efficiently. This book should be useful to system designers as well as advanced
graduate students.
AMBUJ KUMAR SINGH, ASSOCIATE PROFESSOR,
COMPUTER SCIENCE DEPARTMENT,
UNIVERSITY OF CALIFORNIA, SANTA BARBARA
PREFACE
This book presents practice and tools for debugging computer
programs. We also propose new powerful approaches that simplify the
daunting task of debugging complex software systems. Though debugging is
discussed in research papers, its methods have not made into a mainstream
computer science book. This book tries to fill the gap both in an overview of
existing debugging tools with motivating examples and case studies and in
presenting new, state-of-the-art debugging methods. The book also relates
debugging to active databases and rule-based programming languages.
Debugging of computer programs appeared soon after programming
itself. From the beginning of debugging to the present day, researchers and
developers have proposed a plethora of tools to find errors in programs. While
static program errors can be found automatically through syntactic analysis
and semantic checking of language requirements, finding runtime program
errors is a much more complicated task. Though runtime errors are directly
linked to the program text, they also deal with the different universe of
executing instructions, method calls, memory allocations, inter-object
references, and other relations only implied in the original source code. This
duality of the static program text and the dynamic program representation
makes runtime debugging a daunting task. Furthermore, rapid expansion of
object-oriented paradigm together with enormous increase in software
complexity (million line software programs are common nowadays) left
programmers wanting more efficient debugging tools. On the other hand, high
fault-tolerance requirements in electronic commerce demand that systems are
bug-free on delivery.
Object relationships in modem software systems are becoming
increasingly numerous and complex. Program errors due to violations of object
relationships are hard to find because of the cause-effect gap between the time
when an error occurs and the time when the error becomes apparent to the
programmer. Programmers need new tools that allow them to explore objects
in a large system more efficiently and to detect broken object relationships
instantaneously. Such technologies integrate approaches of data visualization,
pattern matching and extraction, database querying, active databases, and rule-