{"id":{"repo_id":"iu","oai_identifier":"oai:scholarworks.iu.edu:2022/15744"},"canonical_url":"https://search.ndltd.org/etd/iu/oai:scholarworks.iu.edu:2022/15744","repository":{"repo_id":"iu","name":"Indiana University","base_url":"https://scholarworks.iu.edu/iuswrrest/oai/request"},"display":{"title":"Flow-Sensitive Control-Flow Analysis in Linear-Log Time","abstract":"The flexibility of dynamically typed languages such as JavaScript, Python, Ruby, and Scheme comes at the cost of run-time type checks. Some of these checks can be eliminated via control-flow analysis. However, traditional control-flow analysis (CFA) is not ideal for this task as it ignores flow-sensitive information that can be gained from dynamic type predicates, such as JavaScript's instanceof and Scheme's pair?, and from type-restricted operators, such as Scheme's car. Yet, adding flow-sensitivity to a traditional CFA worsens the already significant compile-time cost of traditional CFA. This makes it unsuitable for use in just-in-time compilers. In response, this dissertation presents a fast, flow-sensitive type-recovery algorithm based on the linear-time, flow-insensitive sub-0CFA. The algorithm has been implemented as an experimental optimization into Chez Scheme compiler, where it has proven to be effective, justifying the elimination of about 60% of run-time type checks in a large set of bench- marks. The algorithm processes on average over 100,000 lines of code per second and scales well asymptotically, running in only <italic>O</italic>(<italic>n</italic> log <italic>n</italic>) time. This compile-time performance and scalability is achieved through a novel combination of data structures and algorithms.","abstract_html":"The flexibility of dynamically typed languages such as JavaScript, Python, Ruby, and Scheme comes at the cost of run-time type checks. Some of these checks can be eliminated via control-flow analysis. However, traditional control-flow analysis (CFA) is not ideal for this task as it ignores flow-sensitive information that can be gained from dynamic type predicates, such as JavaScript&#x27;s instanceof and Scheme&#x27;s pair?, and from type-restricted operators, such as Scheme&#x27;s car. Yet, adding flow-sensitivity to a traditional CFA worsens the already significant compile-time cost of traditional CFA. This makes it unsuitable for use in just-in-time compilers. In response, this dissertation presents a fast, flow-sensitive type-recovery algorithm based on the linear-time, flow-insensitive sub-0CFA. The algorithm has been implemented as an experimental optimization into Chez Scheme compiler, where it has proven to be effective, justifying the elimination of about 60% of run-time type checks in a large set of bench- marks. The algorithm processes on average over 100,000 lines of code per second and scales well asymptotically, running in only &lt;italic&gt;O&lt;/italic&gt;(&lt;italic&gt;n&lt;/italic&gt; log &lt;italic&gt;n&lt;/italic&gt;) time. This compile-time performance and scalability is achieved through a novel combination of data structures and algorithms.","abstract_has_math":false,"creators":["Adams, Michael D."],"institution":"[Bloomington, Ind.] : Indiana University","degree_name":null,"degree_level":null,"degree_discipline":null,"degree_department":null,"school":null,"contributors":[],"advisors":["Dybvig, R. Kent"],"committee_chairs":[],"committee_members":[],"year":2013,"date_issued":"2013-05-15","date_published":"2013-05-15","updated_at":"2026-11-19T08:12:41Z","subjects":["Control-flow analysis","Flow sensitive","Type recovery"],"languages":["en"],"rights":[],"rights_urls":[],"identifier_entries":[],"person_identifier_entries":[]},"links":{"outbound_url":"https://hdl.handle.net/2022/15744","outbound_label":"Handle","outbound_source":"dc:identifier.uri","record_url":"https://hdl.handle.net/2022/15744","record_label":"Repository record","record_kind":"handle","record_source":"dc:identifier.uri","download_url":null,"download_label":null,"download_source":null,"access_status":null,"embargo_until":null,"access_note":null},"source_record":{"url":"https://scholarworks.iu.edu/iuswrrest/oai/request?verb=GetRecord&metadataPrefix=dim&identifier=oai%3Ascholarworks.iu.edu%3A2022%2F15744","prefix":"dim"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor.advisor","label":"Advisor","values":["Dybvig, R. Kent"]},{"key":"dc:creator","label":"Author","values":["Adams, Michael D."]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date.accessioned","label":"Dc Date Accessioned","values":["2013-05-15T23:42:28Z"]},{"key":"dc:date.available","label":"Dc Date Available","values":["2013-05-15T23:42:28Z"]},{"key":"dc:date.issued","label":"Date","values":["2013-05-15"]},{"key":"dc:date.submitted","label":"Dc Date Submitted","values":["2011"]},{"key":"dc:publisher","label":"Institution","values":["[Bloomington, Ind.] : Indiana University"]},{"key":"dc:type","label":"Dc Type","values":["Doctoral Dissertation"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["Control-flow analysis","Flow sensitive","Type recovery"]},{"key":"dc:subject.classification","label":"Dc Subject Classification","values":["Computer science"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language.iso","label":"Language (ISO)","values":["en"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier.uri","label":"Identifier URI","values":["https://hdl.handle.net/2022/15744"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["Thesis (Ph.D.) - Indiana University, Informatics, 2011"]},{"key":"dc:description.abstract","label":"Abstract","values":["The flexibility of dynamically typed languages such as JavaScript, Python, Ruby, and Scheme comes at the cost of run-time type checks. Some of these checks can be eliminated via control-flow analysis. However, traditional control-flow analysis (CFA) is not ideal for this task as it ignores flow-sensitive information that can be gained from dynamic type predicates, such as JavaScript's instanceof and Scheme's pair?, and from type-restricted operators, such as Scheme's car. Yet, adding flow-sensitivity to a traditional CFA worsens the already significant compile-time cost of traditional CFA. This makes it unsuitable for use in just-in-time compilers. In response, this dissertation presents a fast, flow-sensitive type-recovery algorithm based on the linear-time, flow-insensitive sub-0CFA. The algorithm has been implemented as an experimental optimization into Chez Scheme compiler, where it has proven to be effective, justifying the elimination of about 60% of run-time type checks in a large set of bench- marks. The algorithm processes on average over 100,000 lines of code per second and scales well asymptotically, running in only <italic>O</italic>(<italic>n</italic> log <italic>n</italic>) time. This compile-time performance and scalability is achieved through a novel combination of data structures and algorithms."]},{"key":"dc:title","label":"Title","values":["Flow-Sensitive Control-Flow Analysis in Linear-Log Time"]},{"key":"others:access_status","label":"Others Access Status","values":["open.access"]}]}],"canonical_facts":{"dc:contributor.advisor":["Dybvig, R. Kent"],"dc:creator":["Adams, Michael D."],"dc:date.accessioned":["2013-05-15T23:42:28Z"],"dc:date.available":["2013-05-15T23:42:28Z"],"dc:date.issued":["2013-05-15"],"dc:date.submitted":["2011"],"dc:description":["Thesis (Ph.D.) - Indiana University, Informatics, 2011"],"dc:description.abstract":["The flexibility of dynamically typed languages such as JavaScript, Python, Ruby, and Scheme comes at the cost of run-time type checks. Some of these checks can be eliminated via control-flow analysis. However, traditional control-flow analysis (CFA) is not ideal for this task as it ignores flow-sensitive information that can be gained from dynamic type predicates, such as JavaScript's instanceof and Scheme's pair?, and from type-restricted operators, such as Scheme's car. Yet, adding flow-sensitivity to a traditional CFA worsens the already significant compile-time cost of traditional CFA. This makes it unsuitable for use in just-in-time compilers. In response, this dissertation presents a fast, flow-sensitive type-recovery algorithm based on the linear-time, flow-insensitive sub-0CFA. The algorithm has been implemented as an experimental optimization into Chez Scheme compiler, where it has proven to be effective, justifying the elimination of about 60% of run-time type checks in a large set of bench- marks. The algorithm processes on average over 100,000 lines of code per second and scales well asymptotically, running in only <italic>O</italic>(<italic>n</italic> log <italic>n</italic>) time. This compile-time performance and scalability is achieved through a novel combination of data structures and algorithms."],"dc:identifier.uri":["https://hdl.handle.net/2022/15744"],"dc:language.iso":["en"],"dc:publisher":["[Bloomington, Ind.] : Indiana University"],"dc:subject":["Control-flow analysis","Flow sensitive","Type recovery"],"dc:subject.classification":["Computer science"],"dc:title":["Flow-Sensitive Control-Flow Analysis in Linear-Log Time"],"dc:type":["Doctoral Dissertation"],"others:access_status":["open.access"]},"updated_at":"2026-11-19T08:12:41Z"}