Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62

This work considers static analysis algorithms that are integrated with a development environment. In this context, IDE users can benefit from continuouslyupdated information about the run-time progress of the analysis algorithm (i.e., what portion of the analysis work is completed). IDEs can provid...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Sawin, Jason, Rountev, Atanas
Format: Tagungsbericht
Sprache:eng
Schlagworte:
Online-Zugang:Volltext bestellen
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 62
container_issue
container_start_page 53
container_title
container_volume
creator Sawin, Jason
Rountev, Atanas
description This work considers static analysis algorithms that are integrated with a development environment. In this context, IDE users can benefit from continuouslyupdated information about the run-time progress of the analysis algorithm (i.e., what portion of the analysis work is completed). IDEs can provide the means to convey this information back to the user - for example, the Java IDE in Eclipse achieves this by employing GUI elements such as progress bars. Precise tracking of the run-time progress of an analysis algorithm requires a priori knowledge of the total running time of the analysis. Such knowledge is typically not available, and analysis builders need to employ various heuristics to estimate run-time progress. In this paper we describe our initial work on defining and evaluating such heuristics for a whole-program analysis in Eclipse. The analysis, based on the wellknown Rapid Type Analysis (RTA) approach, builds a call graph for a Java program, for subsequent use in various software tools. We propose multiple heuristics to estimate run-time analysis progress; these heuristics have been implemented in a publicly available Eclipse plug-in. We report the results of evaluating each heuristic on an large set of Java programs.
doi_str_mv 10.1109/SCAM.2006.12
format Conference Proceeding
fullrecord <record><control><sourceid>ieee_6IE</sourceid><recordid>TN_cdi_ieee_primary_4026855</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>4026855</ieee_id><sourcerecordid>4026855</sourcerecordid><originalsourceid>FETCH-LOGICAL-i582-44bbc3529b5e2b484fb0098829297277c29419405ebbc66f70db4cba72568bc63</originalsourceid><addsrcrecordid>eNotjs1KxDAYRQMiqOPs3LnJC7R--ZrfZSnjKFQU7X5oatpG-jMkmYVv74CzunA4HC4hDwxyxsA8fVXlW44AMmd4Re5ASSOwEIW8IdsYfwCAGam44rek3sXk5zb5ZaBpdPTztGSNnx39COsQXIx07WlLq3aa6D60x5FW6xJTOHXJrwstp2ENPo2zKDKJ9-S6b6fotpfdkOZ511QvWf2-f63KOvNCY8a5tV0h0Fjh0HLNewtgtEaDRqFSHRrODAfhzp6UvYJvyzvbKhRSn0mxIY__We-cOxzD-X_4PXBAqYUo_gCF80ir</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62</title><source>IEEE Electronic Library (IEL) Conference Proceedings</source><creator>Sawin, Jason ; Rountev, Atanas</creator><creatorcontrib>Sawin, Jason ; Rountev, Atanas</creatorcontrib><description>This work considers static analysis algorithms that are integrated with a development environment. In this context, IDE users can benefit from continuouslyupdated information about the run-time progress of the analysis algorithm (i.e., what portion of the analysis work is completed). IDEs can provide the means to convey this information back to the user - for example, the Java IDE in Eclipse achieves this by employing GUI elements such as progress bars. Precise tracking of the run-time progress of an analysis algorithm requires a priori knowledge of the total running time of the analysis. Such knowledge is typically not available, and analysis builders need to employ various heuristics to estimate run-time progress. In this paper we describe our initial work on defining and evaluating such heuristics for a whole-program analysis in Eclipse. The analysis, based on the wellknown Rapid Type Analysis (RTA) approach, builds a call graph for a Java program, for subsequent use in various software tools. We propose multiple heuristics to estimate run-time analysis progress; these heuristics have been implemented in a publicly available Eclipse plug-in. We report the results of evaluating each heuristic on an large set of Java programs.</description><identifier>ISBN: 0769523536</identifier><identifier>ISBN: 9780769523538</identifier><identifier>DOI: 10.1109/SCAM.2006.12</identifier><language>eng</language><publisher>IEEE</publisher><subject>Algorithm design and analysis ; Bars ; Conferences ; Graphical user interfaces ; Information analysis ; Java ; Performance analysis ; Programming profession ; Runtime ; State estimation</subject><ispartof>2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation, 2006, p.53-62</ispartof><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/4026855$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,776,780,785,786,2051,27904,54898</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/4026855$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Sawin, Jason</creatorcontrib><creatorcontrib>Rountev, Atanas</creatorcontrib><title>Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62</title><title>2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation</title><addtitle>SCAM</addtitle><description>This work considers static analysis algorithms that are integrated with a development environment. In this context, IDE users can benefit from continuouslyupdated information about the run-time progress of the analysis algorithm (i.e., what portion of the analysis work is completed). IDEs can provide the means to convey this information back to the user - for example, the Java IDE in Eclipse achieves this by employing GUI elements such as progress bars. Precise tracking of the run-time progress of an analysis algorithm requires a priori knowledge of the total running time of the analysis. Such knowledge is typically not available, and analysis builders need to employ various heuristics to estimate run-time progress. In this paper we describe our initial work on defining and evaluating such heuristics for a whole-program analysis in Eclipse. The analysis, based on the wellknown Rapid Type Analysis (RTA) approach, builds a call graph for a Java program, for subsequent use in various software tools. We propose multiple heuristics to estimate run-time analysis progress; these heuristics have been implemented in a publicly available Eclipse plug-in. We report the results of evaluating each heuristic on an large set of Java programs.</description><subject>Algorithm design and analysis</subject><subject>Bars</subject><subject>Conferences</subject><subject>Graphical user interfaces</subject><subject>Information analysis</subject><subject>Java</subject><subject>Performance analysis</subject><subject>Programming profession</subject><subject>Runtime</subject><subject>State estimation</subject><isbn>0769523536</isbn><isbn>9780769523538</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2006</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><sourceid>RIE</sourceid><recordid>eNotjs1KxDAYRQMiqOPs3LnJC7R--ZrfZSnjKFQU7X5oatpG-jMkmYVv74CzunA4HC4hDwxyxsA8fVXlW44AMmd4Re5ASSOwEIW8IdsYfwCAGam44rek3sXk5zb5ZaBpdPTztGSNnx39COsQXIx07WlLq3aa6D60x5FW6xJTOHXJrwstp2ENPo2zKDKJ9-S6b6fotpfdkOZ511QvWf2-f63KOvNCY8a5tV0h0Fjh0HLNewtgtEaDRqFSHRrODAfhzp6UvYJvyzvbKhRSn0mxIY__We-cOxzD-X_4PXBAqYUo_gCF80ir</recordid><startdate>200609</startdate><enddate>200609</enddate><creator>Sawin, Jason</creator><creator>Rountev, Atanas</creator><general>IEEE</general><scope>6IE</scope><scope>6IL</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIL</scope></search><sort><creationdate>200609</creationdate><title>Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62</title><author>Sawin, Jason ; Rountev, Atanas</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i582-44bbc3529b5e2b484fb0098829297277c29419405ebbc66f70db4cba72568bc63</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2006</creationdate><topic>Algorithm design and analysis</topic><topic>Bars</topic><topic>Conferences</topic><topic>Graphical user interfaces</topic><topic>Information analysis</topic><topic>Java</topic><topic>Performance analysis</topic><topic>Programming profession</topic><topic>Runtime</topic><topic>State estimation</topic><toplevel>online_resources</toplevel><creatorcontrib>Sawin, Jason</creatorcontrib><creatorcontrib>Rountev, Atanas</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan All Online (POP All Online) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP All) 1998-Present</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Sawin, Jason</au><au>Rountev, Atanas</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62</atitle><btitle>2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation</btitle><stitle>SCAM</stitle><date>2006-09</date><risdate>2006</risdate><spage>53</spage><epage>62</epage><pages>53-62</pages><isbn>0769523536</isbn><isbn>9780769523538</isbn><abstract>This work considers static analysis algorithms that are integrated with a development environment. In this context, IDE users can benefit from continuouslyupdated information about the run-time progress of the analysis algorithm (i.e., what portion of the analysis work is completed). IDEs can provide the means to convey this information back to the user - for example, the Java IDE in Eclipse achieves this by employing GUI elements such as progress bars. Precise tracking of the run-time progress of an analysis algorithm requires a priori knowledge of the total running time of the analysis. Such knowledge is typically not available, and analysis builders need to employ various heuristics to estimate run-time progress. In this paper we describe our initial work on defining and evaluating such heuristics for a whole-program analysis in Eclipse. The analysis, based on the wellknown Rapid Type Analysis (RTA) approach, builds a call graph for a Java program, for subsequent use in various software tools. We propose multiple heuristics to estimate run-time analysis progress; these heuristics have been implemented in a publicly available Eclipse plug-in. We report the results of evaluating each heuristic on an large set of Java programs.</abstract><pub>IEEE</pub><doi>10.1109/SCAM.2006.12</doi><tpages>10</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext_linktorsrc
identifier ISBN: 0769523536
ispartof 2006 Sixth IEEE International Workshop on Source Code Analysis and Manipulation, 2006, p.53-62
issn
language eng
recordid cdi_ieee_primary_4026855
source IEEE Electronic Library (IEL) Conference Proceedings
subjects Algorithm design and analysis
Bars
Conferences
Graphical user interfaces
Information analysis
Java
Performance analysis
Programming profession
Runtime
State estimation
title Estimating the Run-Time Progress of a Call Graph Construction Algorithm53-62
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-26T00%3A51%3A08IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-ieee_6IE&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Estimating%20the%20Run-Time%20Progress%20of%20a%20Call%20Graph%20Construction%20Algorithm53-62&rft.btitle=2006%20Sixth%20IEEE%20International%20Workshop%20on%20Source%20Code%20Analysis%20and%20Manipulation&rft.au=Sawin,%20Jason&rft.date=2006-09&rft.spage=53&rft.epage=62&rft.pages=53-62&rft.isbn=0769523536&rft.isbn_list=9780769523538&rft_id=info:doi/10.1109/SCAM.2006.12&rft_dat=%3Cieee_6IE%3E4026855%3C/ieee_6IE%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=4026855&rfr_iscdi=true