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...
Gespeichert in:
Hauptverfasser: | , |
---|---|
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 |