Parallel Relative Debugging with Dynamic Data Structures

David Abramson; Raphael Finkel; Donny Kumiawan; Victor Kowalenko; Greg Watson

Parallel Relative Debugging with Dynamic Data Structures

David Abramson, Raphael Finkel, Donny Kumiawan, Victor Kowalenko, Greg Watson

Computer Science

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution › peer-review

1 Scopus citations

Abstract

This paper discusses the use of "relative debugging" as a technique for locating errors in a program that has been ported or developed using evolutionary software engineering techniques. It works on the premise that it is possible to find errors by comparing the contents of key data structures at run time between a "working" version and the new code. Previously, our reference implementation of relative debugging, called Guard, only supported comparison of regular data structures like scalars, simple structures and arrays. Recently, we augmented Guard enabling it to compare dynamically allocated structures like linked lists. Such comparisons are complex because the raw values of pointers cannot be compared directly. Here we describe the changes that were required to support dynamic data types. The functionality is illustrated in a small case study, in which a parallel particle code behaves differently as the number of processors is altered.

Original language	English
Title of host publication	16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003
Editors	Seong-Moo Yoo, Hee Yong Youn
Publisher	International Society for Computers and Their Applications (ISCA)
Pages	22-29
Number of pages	8
ISBN (Electronic)	9781618398161
State	Published - 2003
Event	16th International Conference on Parallel and Distributed Computing Systems, PDCS 2003 - Reno, United States Duration: Aug 13 2003 → Aug 15 2003

Publication series

Name	16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003

Conference

Conference	16th International Conference on Parallel and Distributed Computing Systems, PDCS 2003
Country/Territory	United States
City	Reno
Period	8/13/03 → 8/15/03

Bibliographical note

Publisher Copyright:
© PDCS 2003. All rights reserved.

ASJC Scopus subject areas

Computer Networks and Communications
Hardware and Architecture
Software

Cite this

Abramson, D., Finkel, R., Kumiawan, D., Kowalenko, V., & Watson, G. (2003). Parallel Relative Debugging with Dynamic Data Structures. In S.-M. Yoo, & H. Y. Youn (Eds.), 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003 (pp. 22-29). (16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003). International Society for Computers and Their Applications (ISCA).

Abramson, David ; Finkel, Raphael ; Kumiawan, Donny et al. / Parallel Relative Debugging with Dynamic Data Structures. 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003. editor / Seong-Moo Yoo ; Hee Yong Youn. International Society for Computers and Their Applications (ISCA), 2003. pp. 22-29 (16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003).

@inproceedings{ae8aba4bfed249f6adc9a16c7405aa4d,

title = "Parallel Relative Debugging with Dynamic Data Structures",

abstract = "This paper discusses the use of {"}relative debugging{"} as a technique for locating errors in a program that has been ported or developed using evolutionary software engineering techniques. It works on the premise that it is possible to find errors by comparing the contents of key data structures at run time between a {"}working{"} version and the new code. Previously, our reference implementation of relative debugging, called Guard, only supported comparison of regular data structures like scalars, simple structures and arrays. Recently, we augmented Guard enabling it to compare dynamically allocated structures like linked lists. Such comparisons are complex because the raw values of pointers cannot be compared directly. Here we describe the changes that were required to support dynamic data types. The functionality is illustrated in a small case study, in which a parallel particle code behaves differently as the number of processors is altered.",

author = "David Abramson and Raphael Finkel and Donny Kumiawan and Victor Kowalenko and Greg Watson",

note = "Publisher Copyright: {\textcopyright} PDCS 2003. All rights reserved.; 16th International Conference on Parallel and Distributed Computing Systems, PDCS 2003 ; Conference date: 13-08-2003 Through 15-08-2003",

year = "2003",

language = "English",

series = "16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003",

publisher = "International Society for Computers and Their Applications (ISCA)",

pages = "22--29",

editor = "Seong-Moo Yoo and Youn, {Hee Yong}",

booktitle = "16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003",

address = "United States",

}

Abramson, D, Finkel, R, Kumiawan, D, Kowalenko, V & Watson, G 2003, Parallel Relative Debugging with Dynamic Data Structures. in S-M Yoo & HY Youn (eds), 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003. 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003, International Society for Computers and Their Applications (ISCA), pp. 22-29, 16th International Conference on Parallel and Distributed Computing Systems, PDCS 2003, Reno, United States, 8/13/03.

Parallel Relative Debugging with Dynamic Data Structures. / Abramson, David; Finkel, Raphael; Kumiawan, Donny et al.
16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003. ed. / Seong-Moo Yoo; Hee Yong Youn. International Society for Computers and Their Applications (ISCA), 2003. p. 22-29 (16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003).

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution › peer-review

TY - GEN

T1 - Parallel Relative Debugging with Dynamic Data Structures

AU - Abramson, David

AU - Finkel, Raphael

AU - Kumiawan, Donny

AU - Kowalenko, Victor

AU - Watson, Greg

PY - 2003

Y1 - 2003

N2 - This paper discusses the use of "relative debugging" as a technique for locating errors in a program that has been ported or developed using evolutionary software engineering techniques. It works on the premise that it is possible to find errors by comparing the contents of key data structures at run time between a "working" version and the new code. Previously, our reference implementation of relative debugging, called Guard, only supported comparison of regular data structures like scalars, simple structures and arrays. Recently, we augmented Guard enabling it to compare dynamically allocated structures like linked lists. Such comparisons are complex because the raw values of pointers cannot be compared directly. Here we describe the changes that were required to support dynamic data types. The functionality is illustrated in a small case study, in which a parallel particle code behaves differently as the number of processors is altered.

AB - This paper discusses the use of "relative debugging" as a technique for locating errors in a program that has been ported or developed using evolutionary software engineering techniques. It works on the premise that it is possible to find errors by comparing the contents of key data structures at run time between a "working" version and the new code. Previously, our reference implementation of relative debugging, called Guard, only supported comparison of regular data structures like scalars, simple structures and arrays. Recently, we augmented Guard enabling it to compare dynamically allocated structures like linked lists. Such comparisons are complex because the raw values of pointers cannot be compared directly. Here we describe the changes that were required to support dynamic data types. The functionality is illustrated in a small case study, in which a parallel particle code behaves differently as the number of processors is altered.

UR - http://www.scopus.com/inward/record.url?scp=34548733073&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=34548733073&partnerID=8YFLogxK

M3 - Conference contribution

AN - SCOPUS:34548733073

T3 - 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003

SP - 22

EP - 29

BT - 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003

A2 - Yoo, Seong-Moo

A2 - Youn, Hee Yong

PB - International Society for Computers and Their Applications (ISCA)

T2 - 16th International Conference on Parallel and Distributed Computing Systems, PDCS 2003

Y2 - 13 August 2003 through 15 August 2003

ER -

Abramson D, Finkel R, Kumiawan D, Kowalenko V, Watson G. Parallel Relative Debugging with Dynamic Data Structures. In Yoo SM, Youn HY, editors, 16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003. International Society for Computers and Their Applications (ISCA). 2003. p. 22-29. (16th ISCA International Conference on Parallel and Distributed Computing Systems 2003, PDCS 2003).

Parallel Relative Debugging with Dynamic Data Structures

Abstract

Publication series

Conference

Bibliographical note

ASJC Scopus subject areas

Other files and links

Fingerprint

Cite this