{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/31093"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/31093","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Improved regression testing of multithreaded programs","abstract":"The advent of multicore processors has necessitated the use of parallelism to extract greater software performance. Shared-memory multithreaded programming is currently the dominant parallel programming paradigm. However, multithreaded programs are difficult to get right and are often afflicted by bugs like data races, deadlocks, and atomicity violations which may be triggered only by a specific set of schedules. Multithreaded programs are also difficult to test. Since the behavior of multithreaded programs can depend on the schedule, developers need to express and enforce schedules in multithreaded tests. However, there exists no reliable, modular, efficient, and intuitive methodology for expressing and enforcing schedules in multithreaded tests. Traditionally, developers enforce schedules with time delays, e.g., using Thread.sleep in Java. Unfortunately, this sleep-based approach can produce false positives or negatives, and can result in unnecessarily long testing time. This dissertation presents a novel framework, called IMUnit, for expressing and enforcing schedules reliably and efficiently in multithreaded tests. IMUnit includes a new language for specifying schedules as constraints on events encountered during test execution and a tool for automatically enforcing the specified schedules during test execution. This dissertation also introduces a tool that helps developers migrate their legacy, sleep-based tests into event-based IMUnit tests. The tool uses new techniques for inferring events and schedules from the executions of sleep-based tests. The inference techniques have high precision and recall, of over 75%, and compared to sleep-based tests, IMUnit reduces testing time on average 3.39x. We also describe our experience in migrating over 200 sleep-based tests. Since each multithreaded test can have different results for different schedules, it needs to be explored for multiple schedules (ideally all possible schedules) to ensure the property being tested. Exploration is expensive, especially in the context of regression testing where tests need to be re-explored when programs evolve. Most recent research on testing multithreaded code focuses on improving the exploration for one code version. While there have been promising results, most techniques are slow and do not exploit the fact that code evolves. To improve the exploration of multithreaded tests in the regression testing context, this dissertation proposes a technique, called CAPP, that leverages knowledge about code evolution to prioritize the exploration of multithreaded tests. We evaluated CAPP on the detection of 15 faults in multithreaded Java programs, including large open-source programs, and found that the technique can significantly reduce the exploration required to detect regression faults in multithreaded code compared to the state-of-the-art exploration techniques that do not prioritize exploration based on code evolution.","abstract_html":"The advent of multicore processors has necessitated the use of parallelism to extract greater software performance. Shared-memory multithreaded programming is currently the dominant parallel programming paradigm. However, multithreaded programs are difficult to get right and are often afflicted by bugs like data races, deadlocks, and atomicity violations which may be triggered only by a specific set of schedules. Multithreaded programs are also difficult to test. Since the behavior of multithreaded programs can depend on the schedule, developers need to express and enforce schedules in multithreaded tests. However, there exists no reliable, modular, efficient, and intuitive methodology for expressing and enforcing schedules in multithreaded tests. Traditionally, developers enforce schedules with time delays, e.g., using Thread.sleep in Java. Unfortunately, this sleep-based approach can produce false positives or negatives, and can result in unnecessarily long testing time. This dissertation presents a novel framework, called IMUnit, for expressing and enforcing schedules reliably and efficiently in multithreaded tests. IMUnit includes a new language for specifying schedules as constraints on events encountered during test execution and a tool for automatically enforcing the specified schedules during test execution. This dissertation also introduces a tool that helps developers migrate their legacy, sleep-based tests into event-based IMUnit tests. The tool uses new techniques for inferring events and schedules from the executions of sleep-based tests. The inference techniques have high precision and recall, of over 75%, and compared to sleep-based tests, IMUnit reduces testing time on average 3.39x. We also describe our experience in migrating over 200 sleep-based tests. Since each multithreaded test can have different results for different schedules, it needs to be explored for multiple schedules (ideally all possible schedules) to ensure the property being tested. Exploration is expensive, especially in the context of regression testing where tests need to be re-explored when programs evolve. Most recent research on testing multithreaded code focuses on improving the exploration for one code version. While there have been promising results, most techniques are slow and do not exploit the fact that code evolves. To improve the exploration of multithreaded tests in the regression testing context, this dissertation proposes a technique, called CAPP, that leverages knowledge about code evolution to prioritize the exploration of multithreaded tests. We evaluated CAPP on the detection of 15 faults in multithreaded Java programs, including large open-source programs, and found that the technique can significantly reduce the exploration required to detect regression faults in multithreaded code compared to the state-of-the-art exploration techniques that do not prioritize exploration based on code evolution.","abstract_has_math":false,"creators":["Jagannath, Vilas"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"Ph.D.","degree_level":"Dissertation","degree_discipline":"Computer Science Computer Science","degree_department":null,"school":null,"contributors":["Marinov, Darko","Agha, Gul A.","Roşu, Grigore","Hind, Michael"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2012,"date_issued":"2012-05-22T00:27:26Z","date_published":"2012-05-22T00:27:26Z","updated_at":"2026-07-22T22:25:30Z","subjects":["mutithreaded","regression testing","unit testing","IMUnit","Change-Aware Preemption Prioritization (CAPP)"],"languages":["en"],"rights":["Copyright 2012 Vilas Shekhar Bangalore Jagannath"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/31093","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Marinov, Darko","Agha, Gul A.","Roşu, Grigore","Hind, Michael"]},{"key":"dc:creator","label":"Author","values":["Jagannath, Vilas"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2012-05-22T00:27:26Z","2012-05"]},{"key":"dc:type","label":"Dc Type","values":["text"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science Computer Science"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Dissertation"]},{"key":"thesis:degree_name","label":"Degree Name","values":["Ph.D."]},{"key":"thesis:institution_name","label":"Thesis Institution Name","values":["University of Illinois at Urbana-Champaign"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["mutithreaded","regression testing","unit testing","IMUnit","Change-Aware Preemption Prioritization (CAPP)"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["Copyright 2012 Vilas Shekhar Bangalore Jagannath"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/31093"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["The advent of multicore processors has necessitated the use of parallelism to extract greater software performance. Shared-memory multithreaded programming is currently the dominant parallel programming paradigm. However, multithreaded programs are difficult to get right and are often afflicted by bugs like data races, deadlocks, and atomicity violations which may be triggered only by a specific set of schedules. Multithreaded programs are also difficult to test. Since the behavior of multithreaded programs can depend on the schedule, developers need to express and enforce schedules in multithreaded tests. However, there exists no reliable, modular, efficient, and intuitive methodology for expressing and enforcing schedules in multithreaded tests. Traditionally, developers enforce schedules with time delays, e.g., using Thread.sleep in Java. Unfortunately, this sleep-based approach can produce false positives or negatives, and can result in unnecessarily long testing time. This dissertation presents a novel framework, called IMUnit, for expressing and enforcing schedules reliably and efficiently in multithreaded tests. IMUnit includes a new language for specifying schedules as constraints on events encountered during test execution and a tool for automatically enforcing the specified schedules during test execution. This dissertation also introduces a tool that helps developers migrate their legacy, sleep-based tests into event-based IMUnit tests. The tool uses new techniques for inferring events and schedules from the executions of sleep-based tests. The inference techniques have high precision and recall, of over 75%, and compared to sleep-based tests, IMUnit reduces testing time on average 3.39x. We also describe our experience in migrating over 200 sleep-based tests. Since each multithreaded test can have different results for different schedules, it needs to be explored for multiple schedules (ideally all possible schedules) to ensure the property being tested. Exploration is expensive, especially in the context of regression testing where tests need to be re-explored when programs evolve. Most recent research on testing multithreaded code focuses on improving the exploration for one code version. While there have been promising results, most techniques are slow and do not exploit the fact that code evolves. To improve the exploration of multithreaded tests in the regression testing context, this dissertation proposes a technique, called CAPP, that leverages knowledge about code evolution to prioritize the exploration of multithreaded tests. We evaluated CAPP on the detection of 15 faults in multithreaded Java programs, including large open-source programs, and found that the technique can significantly reduce the exploration required to detect regression faults in multithreaded code compared to the state-of-the-art exploration techniques that do not prioritize exploration based on code evolution.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2012-04-19T23:59:02Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 Jagannath_Vilas.pdf: 828462 bytes, checksum: ad98e4597768e9c72620df4d90640d33 (MD5)","Made available in DSpace on 2012-05-22T00:27:26Z (GMT). No. of bitstreams: 2 Jagannath_Vilas.pdf: 828462 bytes, checksum: ad98e4597768e9c72620df4d90640d33 (MD5) license.txt: 4065 bytes, checksum: 469b2558a5b3ca8c905a833cd3681461 (MD5)"]},{"key":"dc:title","label":"Title","values":["Improved regression testing of multithreaded programs"]}]}],"canonical_facts":{"dc:contributor":["Marinov, Darko","Agha, Gul A.","Roşu, Grigore","Hind, Michael"],"dc:creator":["Jagannath, Vilas"],"dc:date":["2012-05-22T00:27:26Z","2012-05"],"dc:description":["The advent of multicore processors has necessitated the use of parallelism to extract greater software performance. Shared-memory multithreaded programming is currently the dominant parallel programming paradigm. However, multithreaded programs are difficult to get right and are often afflicted by bugs like data races, deadlocks, and atomicity violations which may be triggered only by a specific set of schedules. Multithreaded programs are also difficult to test. Since the behavior of multithreaded programs can depend on the schedule, developers need to express and enforce schedules in multithreaded tests. However, there exists no reliable, modular, efficient, and intuitive methodology for expressing and enforcing schedules in multithreaded tests. Traditionally, developers enforce schedules with time delays, e.g., using Thread.sleep in Java. Unfortunately, this sleep-based approach can produce false positives or negatives, and can result in unnecessarily long testing time. This dissertation presents a novel framework, called IMUnit, for expressing and enforcing schedules reliably and efficiently in multithreaded tests. IMUnit includes a new language for specifying schedules as constraints on events encountered during test execution and a tool for automatically enforcing the specified schedules during test execution. This dissertation also introduces a tool that helps developers migrate their legacy, sleep-based tests into event-based IMUnit tests. The tool uses new techniques for inferring events and schedules from the executions of sleep-based tests. The inference techniques have high precision and recall, of over 75%, and compared to sleep-based tests, IMUnit reduces testing time on average 3.39x. We also describe our experience in migrating over 200 sleep-based tests. Since each multithreaded test can have different results for different schedules, it needs to be explored for multiple schedules (ideally all possible schedules) to ensure the property being tested. Exploration is expensive, especially in the context of regression testing where tests need to be re-explored when programs evolve. Most recent research on testing multithreaded code focuses on improving the exploration for one code version. While there have been promising results, most techniques are slow and do not exploit the fact that code evolves. To improve the exploration of multithreaded tests in the regression testing context, this dissertation proposes a technique, called CAPP, that leverages knowledge about code evolution to prioritize the exploration of multithreaded tests. We evaluated CAPP on the detection of 15 faults in multithreaded Java programs, including large open-source programs, and found that the technique can significantly reduce the exploration required to detect regression faults in multithreaded code compared to the state-of-the-art exploration techniques that do not prioritize exploration based on code evolution.","Item withdrawn by Mark Zulauf (zulauf@illinois.edu) on 2012-04-19T23:59:02Z Item was in collections: University of Illinois Theses & Dissertations (ID: 1) No. of bitstreams: 1 Jagannath_Vilas.pdf: 828462 bytes, checksum: ad98e4597768e9c72620df4d90640d33 (MD5)","Made available in DSpace on 2012-05-22T00:27:26Z (GMT). No. of bitstreams: 2 Jagannath_Vilas.pdf: 828462 bytes, checksum: ad98e4597768e9c72620df4d90640d33 (MD5) license.txt: 4065 bytes, checksum: 469b2558a5b3ca8c905a833cd3681461 (MD5)"],"dc:identifier":["http://hdl.handle.net/2142/31093"],"dc:language":["en"],"dc:rights":["Copyright 2012 Vilas Shekhar Bangalore Jagannath"],"dc:subject":["mutithreaded","regression testing","unit testing","IMUnit","Change-Aware Preemption Prioritization (CAPP)"],"dc:title":["Improved regression testing of multithreaded programs"],"dc:type":["text"],"thesis:degree_discipline":["Computer Science Computer Science"],"thesis:degree_level":["Dissertation"],"thesis:degree_name":["Ph.D."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:25:30Z"}