+publisher:"University of Illinois – Urbana-Champaign" +contributor:("Marinov, Darko")

University of Illinois – Urbana-Champaign

1. Zhao, Peiyuan. Comparing module- and class-level regression test selection in continuous integration.

Degree: MS, Computer Science, 2018, University of Illinois – Urbana-Champaign

► Developers rely on regression testing in their continuous integration (CI) environment to find if their changes introduce faults. While regression testing is widely practiced, it… (more)

▼ Developers rely on regression testing in their continuous integration (CI) environment to find if their changes introduce faults. While regression testing is widely practiced, it is very costly. Regression test selection (RTS) reduces the cost of regression testing by running only the tests that are affected by the changes. Industry has adopted module-level RTS running in a CI environment. Researchers have recently proposed class-level RTS but did not evaluate it in a CI environment. In this work, we compare module-level and class-level RTS techniques in a CI environment. Specifically, we evaluate GIB, a module-level RTS technique, and Ekstazi, a class-level RTS technique, on Travis CI, a popular CI service for open-source projects. We also propose a hybrid RTS technique, GIBstazi, that combines aspects of the module-level and class-level RTS techniques. GIBstazi is safer than Ekstazi because GIBstazi tracks non-source-code changes while Ekstazi does not. We evaluate all the techniques on Travis CI using real, historical commits that were built on Travis CI. Our results show that all the RTS techniques do save testing time compared to running all tests (RetestAll) in a CI environment, but the savings in the end-to-end time for a full build is not as high as shown in previous work in a local environment running with a dedicated machine due to the extra overhead in a CI environment. Moreover, we are the first to inspect test failures from RetestAll builds. We find that these failures are often not selected by the RTS techniques, but almost all test failures missed by the RTS techniques are from so called flaky tests, which can pass or fail nondeterministically regardless of the code changes. The overall results show that RTS can be beneficial for the developers, hybrid GIBstazi gives the best trade-off, and RTS not only saves time but also avoids misleading developers by flaky test failures. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor).

Subjects/Keywords: Software Testing; Regression Testing

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Zhao, P. (2018). Comparing module- and class-level regression test selection in continuous integration. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/101059

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Zhao, Peiyuan. “Comparing module- and class-level regression test selection in continuous integration.” 2018. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/101059.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Zhao, Peiyuan. “Comparing module- and class-level regression test selection in continuous integration.” 2018. Web. 28 Feb 2021.

Vancouver:

Zhao P. Comparing module- and class-level regression test selection in continuous integration. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2018. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/101059.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Zhao P. Comparing module- and class-level regression test selection in continuous integration. [Thesis]. University of Illinois – Urbana-Champaign; 2018. Available from: http://hdl.handle.net/2142/101059

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

University of Illinois – Urbana-Champaign

2. Hadzi-Tanovic, Milica. Reflection-aware static regression test selection.

Degree: MS, Computer Science, 2018, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/101065

► Regression test selection (RTS) aims to speed up regression testing by rerunning only tests that are affected by code changes. RTS can be performed using… (more)

▼ Regression test selection (RTS) aims to speed up regression testing by rerunning only tests that are affected by code changes. RTS can be performed using dynamic or static analysis techniques. A recent study showed that static and dynamic RTS can perform similarly for some medium-sized Java projects. However, the results also showed that static RTS can be sometimes unsafe, missing to select some tests that dynamic RTS selects, and reflection was the only cause of unsafety among the evaluated projects. In this thesis, we investigate five techniques—three purely static techniques and two hybrid static-dynamic techniques—to make static RTS safe with respect to reflection. We implemented four of these reflection-aware techniques as extensions to one reflection-unaware (RU) static RTS technique in a tool called STARTS. We evaluated the fifth technique but did not yet fully implement it. To assess reflection-aware SRTS techniques, we measured benefits and costs of four implemented reflection-aware techniques by comparing their end-to-end times with the RU technique and with RetestAll—the latter runs all tests after every code change. We also compared safety and precision of all five static RTS techniques relative to Ekstazi, a state-of-the-art dynamic RTS technique. Our results on 805 revisions of 22 open-source Java projects show that all reflection-aware techniques we evaluated can make static RTS safe with respect to reflection, but their costs vary widely. The best purely static technique in our study is based on border analysis with minimal border methods which avoids analyzing JDK and saves, on average, 14.1% of the end-to-end time of RetestAll. Furthermore, the results show that a hybrid technique based on per-test analysis is very promising in terms of safety and precision. On the other hand, the worst techniques were based on string analysis; these techniques are imprecise and often lead to selecting to re-run all tests. Taken together, these results show the need for more research into purely static techniques for making static RTS reflection aware. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor).

Subjects/Keywords: regression test selection; reflection; static analysis

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Hadzi-Tanovic, M. (2018). Reflection-aware static regression test selection. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/101065

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Hadzi-Tanovic, Milica. “Reflection-aware static regression test selection.” 2018. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/101065.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Hadzi-Tanovic, Milica. “Reflection-aware static regression test selection.” 2018. Web. 28 Feb 2021.

Vancouver:

Hadzi-Tanovic M. Reflection-aware static regression test selection. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2018. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/101065.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Hadzi-Tanovic M. Reflection-aware static regression test selection. [Thesis]. University of Illinois – Urbana-Champaign; 2018. Available from: http://hdl.handle.net/2142/101065

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

University of Illinois – Urbana-Champaign

3. Shi, August Wang. Improving regression testing efficiency and reliability via test-suite transformations.

Degree: PhD, Computer Science, 2020, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/108492

► As software becomes more important and ubiquitous, high quality software also becomes crucial. Developers constantly make changes to improve software, and they rely on regression… (more)

▼ As software becomes more important and ubiquitous, high quality software also becomes crucial. Developers constantly make changes to improve software, and they rely on regression testing—the process of running tests after every change—to ensure that changes do not break existing functionality. Regression testing is widely used both in industry and in open source, but it suffers from two main challenges. (1) Regression testing is costly. Developers run a large number of tests in the test suite after every change, and changes happen very frequently. The cost is both in the time developers spend waiting for the tests to finish running so that developers know whether the changes break existing functionality, and in the monetary cost of running the tests on machines. (2) Regression test suites contain flaky tests, which nondeterministically pass or fail when run on the same version of code, regardless of any changes. Flaky test failures can mislead developers into believing that their changes break existing functionality, even though those tests can fail without any changes. Developers will therefore waste time trying to debug non existent faults in their changes. This dissertation proposes three lines of work that address these challenges of regression testing through test-suite transformations that modify test suites to make them more efficient or more reliable. Specifically, two lines of work explore how to reduce the cost of regression testing and one line of work explores how to fix existing flaky tests. First, this dissertation investigates the effectiveness of test-suite reduction (TSR), a traditional test-suite transformation that removes tests deemed redundant with respect to other tests in the test suite based on heuristics. TSR outputs a smaller, reduced test suite to be run in the future. However, TSR risks removing tests that can potentially detect faults in future changes. While TSR was proposed over two decades ago, it was always evaluated using program versions with seeded faults. Such evaluations do not precisely predict the effectiveness of the reduced test suite on the future changes. This dissertation evaluates TSR in a real-world setting using real software evolution with real test failures. The results show that TSR techniques proposed in the past are not as effective as suggested by traditional TSR metrics, and those same metrics do not predict how effective a reduced test suite is in the future. Researchers need to either propose new TSR techniques that produce more effective reduced test suites or better metrics for predicting the effectiveness of reduced test suites. Second, this dissertation proposes a new transformation to improve regression testing cost when using a modern build system by optimizing the placement of tests, implemented in a technique called TestOptimizer. Modern build systems treat a software project as a group of inter-dependent modules, including test modules that contain only tests. As such, when developers make a change, the build system can use a developer-specified… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Adve%2C%20Vikram%22%29&pagesize-30">Adve, Vikram (committee member), Champaign%22%20%2Bcontributor%3A%28%22Misailovic%2C%20Sasa%22%29&pagesize-30">Misailovic, Sasa (committee member), Champaign%22%20%2Bcontributor%3A%28%22Khurshid%2C%20Sarfraz%22%29&pagesize-30">Khurshid, Sarfraz (committee member).

Subjects/Keywords: software engineering; software testing; regression testing; flaky tests

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Shi, A. W. (2020). Improving regression testing efficiency and reliability via test-suite transformations. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/108492

Chicago Manual of Style (16^th Edition):

Shi, August Wang. “Improving regression testing efficiency and reliability via test-suite transformations.” 2020. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/108492.

MLA Handbook (7^th Edition):

Shi, August Wang. “Improving regression testing efficiency and reliability via test-suite transformations.” 2020. Web. 28 Feb 2021.

Vancouver:

Shi AW. Improving regression testing efficiency and reliability via test-suite transformations. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2020. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/108492.

Council of Science Editors:

Shi AW. Improving regression testing efficiency and reliability via test-suite transformations. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2020. Available from: http://hdl.handle.net/2142/108492

University of Illinois – Urbana-Champaign

4. Nistor, Adrian. Understanding, detecting, and repairing performance bugs.

Degree: PhD, 0112, 2014, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/49706

► Software performance is critical for how end-users perceive the quality of software products. Performance bugs – programming errors that cause performance degradation—lead to poor user experience… (more)

▼ Software performance is critical for how end-users perceive the quality of software products. Performance bugs – programming errors that cause performance degradation—lead to poor user experience and low system throughput. Despite advances in profiling techniques, performance bugs still escape in production runs. There are two key reasons why performance bugs are not effectively detected during in-house testing. First, there is little available data about how performance bugs are discovered, reported, and fixed in practice. Such data is required when designing effective techniques for addressing performance bugs. Second, the current techniques for detecting performance bugs detect only slow computation and do not address other important parts of the testing process, such as automated oracles or bug fixing. This dissertation makes three contributions. The first contribution is a study of how performance bugs are discovered, reported to developers, and fixed by developers, and how these results compare with the results for non-performance bugs. The study considers performance and non-performance bugs from three popular code bases: Eclipse JDT, Eclipse SWT, and Mozilla. First, we find little evidence that fixing performance bugs has a higher chance to introduce new functional bugs than fixing non-performance bugs, which implies that developers may not need to be over-concerned about fixing performance bugs. Second, although fixing performance bugs is about as error-prone as fixing non-performance bugs, fixing performance bugs is more difficult than fixing non-performance bugs, indicating that developers need better tool support for fixing performance bugs and testing performance bug patches. Third, unlike many non-performance bugs, a large percentage of performance bugs are discovered through code reasoning, not through users observing the negative effects of the bugs (e.g., performance degradation) or through profiling. The result suggests that techniques to help developers reason about performance, better test oracles, and better profiling techniques are needed for discovering performance bugs. The second contribution is TODDLER, a novel automated oracle for performance bugs, which enables testing for performance bugs to use the well established and automated process of testing for functional bugs. TODDLER reports code loops whose computation has repetitive and partially similar memory-access patterns across loop iterations. Such repetitive work is likely unnecessary and can be done faster. TODDLER was implemented for Java and evaluated on 9 popular Java codebases. The experiments with 11 previously known, real-world performance bugs show that TODDLER finds these bugs with a higher accuracy than the standard Java profiler. TODDLER also found 42 new bugs in six Java projects: Ant, Google Core Libraries, JUnit, Apache Collections, JDK, and JFreeChart. Based on the corresponding bug reports, developers so far fixed 10 bugs and confirmed 6 more as real bugs. The third contribution is LULLABY, a novel… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Lu%2C%20Shan%22%29&pagesize-30">Lu, Shan (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Lu%2C%20Shan%22%29&pagesize-30">Lu, Shan (committee member), Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member).

Subjects/Keywords: Performance bugs

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Nistor, A. (2014). Understanding, detecting, and repairing performance bugs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/49706

Chicago Manual of Style (16^th Edition):

Nistor, Adrian. “Understanding, detecting, and repairing performance bugs.” 2014. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/49706.

MLA Handbook (7^th Edition):

Nistor, Adrian. “Understanding, detecting, and repairing performance bugs.” 2014. Web. 28 Feb 2021.

Vancouver:

Nistor A. Understanding, detecting, and repairing performance bugs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2014. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/49706.

Council of Science Editors:

Nistor A. Understanding, detecting, and repairing performance bugs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2014. Available from: http://hdl.handle.net/2142/49706

University of Illinois – Urbana-Champaign

5. Hariri, Farah. Exploring design decisions for mutation testing.

Degree: PhD, Computer Science, 2018, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/101008

► Software testing is by far the most popular technique used in industry for quality assurance. One key challenge of software testing is how to evaluate… (more)

▼ Software testing is by far the most popular technique used in industry for quality assurance. One key challenge of software testing is how to evaluate the quality of test suites in terms of their bug-finding capability. A test suite with a large number of tests, or that achieves a high statement or branch coverage, does not necessarily have a high bug-finding capability. Mutation testing is widely used in research to evaluate the quality of test suites, and it is often considered the most powerful approach for this purpose. Mutation testing proceeds in two steps. The first step is mutant generation. A mutant is a modified version of the original program obtained by applying a mutation operator. A mutation operator is a program transformation that introduces a small syntactic change to the original program. The second step of mutation testing is to run the test suite and determine which mutants are killed, i.e., which mutants lead to tests having a different output when run on them compared against running on the original program. Mutation testing produces a measure of quality of the test suite called mutation score. The mutation score of a given test suite is the percentage of mutants killed by that test suite out of the total number of generated mutants. In this dissertation, we explore three design decisions related to mutation testing and provide recommendations to researchers in those regards. First, we look into mutation operators. To provide insights about how to improve the test suites, mutation testing requires both high quality and diverse mutation operators that lead to different program behaviors. We propose the use of approximate transformations as mutation operators. Approximate transformations were introduced in the emerging area of approximate computing for changing program semantics to trade the accuracy of results for improved energy efficiency or performance. We compared three approximate transformations with a set of conventional mutation operators from the literature, on nine open-source Java subjects. The results showed that approximate transformations change program behavior differently from conventional mutation operators. Our analysis uncovered code patterns in which approximate mutants survived (i.e., were not killed) and showed the practical value of approximate transformations both for understanding code amenable to approximations and for discovering bad tests. We submitted 11 pull requests to fix bad tests. Seven have already been integrated by the developers. Second, we explore the effect of compiler optimizations on mutation testing. Multiple mutation testing tools were developed that perform mutation at different levels. More recently mutation testing has been performed at the level of compiler intermediate representation (IR), e.g., for the LLVM IR and Java bytecode/IR. Compiler optimizations are automatic program transformations applied at the IR level with the goal of improving a measure of program performance, while preserving program semantics. Applying mutations at the IR level… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Misailovic%2C%20Sasa%22%29&pagesize-30">Misailovic, Sasa (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22Khurshid%2C%20Sarfraz%22%29&pagesize-30">Khurshid, Sarfraz (committee member).

Subjects/Keywords: software testing; mutation testing

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Hariri, F. (2018). Exploring design decisions for mutation testing. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/101008

Chicago Manual of Style (16^th Edition):

Hariri, Farah. “Exploring design decisions for mutation testing.” 2018. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/101008.

MLA Handbook (7^th Edition):

Hariri, Farah. “Exploring design decisions for mutation testing.” 2018. Web. 28 Feb 2021.

Vancouver:

Hariri F. Exploring design decisions for mutation testing. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2018. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/101008.

Council of Science Editors:

Hariri F. Exploring design decisions for mutation testing. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2018. Available from: http://hdl.handle.net/2142/101008

University of Illinois – Urbana-Champaign

6. Yang, Wei. Adversarial-resilience assurance for mobile security systems.

Degree: PhD, Computer Science, 2018, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/101204

► As mobile phones become an increasingly critical part of our world, ensuring the security and privacy of mobile applications (in short as apps) becomes increasingly… (more)

▼ As mobile phones become an increasingly critical part of our world, ensuring the security and privacy of mobile applications (in short as apps) becomes increasingly important. For too long, researchers have often tackled security in an attack-driven, ad hoc, and reactionary manner with large manual efforts devoted by security analysts. In the efforts of making security systems automated and systematic, multiple intelligent techniques, such as program analysis and machine learning, have been introduced in the mobile security systems for better security decision making. However, these intelligent techniques are originally proposed for domains such as image recognition, Virtual Personal Assistants, and software testing without considering the presence of adversaries. In this dissertation, we present three main bodies of research on adversarial resiliency of intelligent techniques used in mobile security systems. We first present how intelligent techniques can be adapted for automated decision making in mobile security systems. Then we investigate the possibility to design and implement systematic attack strategies that are specifically adversarial to these newly-proposed intelligent techniques. Last, based on the findings that the intelligent techniques are indeed susceptible to the adversarial attacks, we develop techniques to further strengthen the adversarial resiliency of intelligent techniques toward these adversarial attacks. In particular, we use mobile malware detection as a representative of security systems for our investigation. To show how a malware detection approach can be enhanced by intelligent techniques such as machine learning and static program analysis, we propose AppContext, an approach that identifies malware with 87.7% precision and 95% recall. To show the possibility to attack intelligent techniques such as machine learning, we propose MRV, an approach that automatically constructs more than hundreds of new malware variants compromising state-of-the-art learning-based malware detectors. To strengthen the adversarial resiliency against obfuscation techniques used by malware to confuse static analysis, we propose EnMobile, which detects malware with substantially higher precision and recall than four state-of-the-art approaches, namely Apposcopy, Drebin, MUDFLOW, and AppContext. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (advisor), Champaign%22%20%2Bcontributor%3A%28%22Gunter%2C%20Carl%22%29&pagesize-30">Gunter, Carl (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Prasad%2C%20Mukul%22%29&pagesize-30">Prasad, Mukul (committee member).

Subjects/Keywords: Mobile Security; Adversarial Machine Learning

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Yang, W. (2018). Adversarial-resilience assurance for mobile security systems. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/101204

Chicago Manual of Style (16^th Edition):

Yang, Wei. “Adversarial-resilience assurance for mobile security systems.” 2018. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/101204.

MLA Handbook (7^th Edition):

Yang, Wei. “Adversarial-resilience assurance for mobile security systems.” 2018. Web. 28 Feb 2021.

Vancouver:

Yang W. Adversarial-resilience assurance for mobile security systems. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2018. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/101204.

Council of Science Editors:

Yang W. Adversarial-resilience assurance for mobile security systems. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2018. Available from: http://hdl.handle.net/2142/101204

University of Illinois – Urbana-Champaign

7. Kumar, Rajesh. Efficient execution of fine-grained actors on multicore processors.

Degree: PhD, 0112, 2013, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/44758

► The Actor model is a promising model for programming new computing platforms such as the multicores and cloud computers, primarily due to features such as… (more)

▼ The Actor model is a promising model for programming new computing platforms such as the multicores and cloud computers, primarily due to features such as inherent concurrency and isolation of state. However, the model is often perceived to be fundamentally inefficient on stock multicore processors. Consequently, we find that standard semantic properties of the model, including encapsulation and fairness, are ignored even by languages and frameworks that claim to be based on the Actor model. In this work, we propose and implement both static (compiler) and dynamic (runtime) techniques that overcome these perceived inefficiencies, while retaining key actor semantics, even in a framework setting. We compare the performance of ActorFoundry with other frameworks for small benchmarks and programs. The results suggest that key actor semantics can be supported in an actor framework without compromising execution efficiency. We also validate our results for a large real-world application, i.e. a Java game called Quantum having more than 25k lines of code. Quantum is a real-time strategy game, which employs a few threads for handling IO, UI and network events. We port the Quantum game to ActorFoundry, so that the asynchrony due to threads and communication between them is expressed using actors and messages. Next, we introduce additional concurrency in Quantum by actorizing all game objects. This results in relatively fine-grained actors. We are able to run a game instance with more than 10,000 game objects, which keeps an 8-core computer at full throttle. According to our knowledge, this is the largest execution of a real client-side actor program. The performance is comparable to an Actor framework implementation that does not provide the standard actor semantics. Moreover, our set of static (compiler) and dynamic (runtime) techniques allow an actor framework to compare well against a shared memory model in terms of execution efficiency. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%20A.%22%29&pagesize-30">Agha, Gul A. (advisor), Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%20A.%22%29&pagesize-30">Agha, Gul A. (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Johnson%2C%20Ralph%20E.%22%29&pagesize-30">Johnson, Ralph E. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Miller%2C%20Mark%20S.%22%29&pagesize-30">Miller, Mark S. (committee member).

Subjects/Keywords: multicore; efficiency; performance; actor model; concurrency; parallelism; programming; ActorFoundry; games

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Kumar, R. (2013). Efficient execution of fine-grained actors on multicore processors. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/44758

Chicago Manual of Style (16^th Edition):

Kumar, Rajesh. “Efficient execution of fine-grained actors on multicore processors.” 2013. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/44758.

MLA Handbook (7^th Edition):

Kumar, Rajesh. “Efficient execution of fine-grained actors on multicore processors.” 2013. Web. 28 Feb 2021.

Vancouver:

Kumar R. Efficient execution of fine-grained actors on multicore processors. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2013. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/44758.

Council of Science Editors:

Kumar R. Efficient execution of fine-grained actors on multicore processors. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2013. Available from: http://hdl.handle.net/2142/44758

University of Illinois – Urbana-Champaign

8. Qi, Shanxiang. Techniques to detect and avert advanced software concurrency bugs.

Degree: PhD, 0112, 2013, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/45603

► Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. One challenging… (more)

▼ Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. One challenging problem is how to ship correct programs. Dynamic analysis tools are very useful to find errors in parallel programs by automatically analyzing the runtime information. They often capture errors from well-tested programs. However, existing dynamic analysis tools suffer from two problems: high false positive rate and high overhead. High false positive rate means lots of errors reported by the dynamic analysis tool may be benign or non-existent. For example, lots of data races detected by a race detection tool could be relatively benign data races. Also, many dynamic software analyses cause orders-ofmagnitude slowdowns, which users cannot tolerate at runtime. This dissertation contains three parts. The first two parts propose two different schemes to reduce the false positives and overhead of race detecting tools. These two schemes can detect and tolerate two different types of harmful races with low overhead: asymmetric data races and IF-condition data races. An asymmetric data race occurs when at least one of the racing threads is inside a critical section. Our proposal to detect and tolerate asymmetric data races is called Pacman. It exploits cache coherence hardware to temporarily protect the variables that a thread accesses in a critical section from other threads’s requests. An IF-condition data race is one where a memory location accessed by a thread (T1) in the control expression of an IF statement suffers a race while T1 is executing the THEN or ELSE clauses. T1 may or may not access again the location in the THEN or ELSE clauses. Our second proposal presents two techniques to handle IF-condition races dynamically. They rely on simple code transformations and, in one case, on additional hardware help. The third part proposes a general hardware framework to provide fine-grained memory monitoring with low overhead. This mechanism can be used to reduce the overhead of many dynamic software analyses. Overall, this dissertation aims at designing novel schemes to reduce the false positive rate and overhead of dynamic software analyses in order to make parallel programs more robust. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (advisor), Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22King%2C%20Samuel%20T.%22%29&pagesize-30">King, Samuel T. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Lu%2C%20Shan%22%29&pagesize-30">Lu, Shan (committee member).

Subjects/Keywords: concurrency bugs; data race detection; dynamic analysis

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Qi, S. (2013). Techniques to detect and avert advanced software concurrency bugs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/45603

Chicago Manual of Style (16^th Edition):

Qi, Shanxiang. “Techniques to detect and avert advanced software concurrency bugs.” 2013. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/45603.

MLA Handbook (7^th Edition):

Qi, Shanxiang. “Techniques to detect and avert advanced software concurrency bugs.” 2013. Web. 28 Feb 2021.

Vancouver:

Qi S. Techniques to detect and avert advanced software concurrency bugs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2013. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/45603.

Council of Science Editors:

Qi S. Techniques to detect and avert advanced software concurrency bugs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2013. Available from: http://hdl.handle.net/2142/45603

University of Illinois – Urbana-Champaign

9. Lee, Choonghwan. Preparation-free and comprehensive runtime verification tool for testing Java programs.

Degree: PhD, 0112, 2014, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/46910

► Runtime verification is an effective and accurate technique for ensuring that an execution of a program conform to certain specifications at runtime. Although excessive runtime… (more)

Subjects/Keywords: parametric specification; specification mining; runtime verification

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Lee, C. (2014). Preparation-free and comprehensive runtime verification tool for testing Java programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/46910

Chicago Manual of Style (16^th Edition):

Lee, Choonghwan. “Preparation-free and comprehensive runtime verification tool for testing Java programs.” 2014. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/46910.

MLA Handbook (7^th Edition):

Lee, Choonghwan. “Preparation-free and comprehensive runtime verification tool for testing Java programs.” 2014. Web. 28 Feb 2021.

Vancouver:

Lee C. Preparation-free and comprehensive runtime verification tool for testing Java programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2014. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/46910.

Council of Science Editors:

Lee C. Preparation-free and comprehensive runtime verification tool for testing Java programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2014. Available from: http://hdl.handle.net/2142/46910

University of Illinois – Urbana-Champaign

10. Hafiz, Munawar. Security on demand.

Degree: PhD, 0112, 2011, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/18413

► Security experts generally believe that, "security cannot be added on, it must be designed from the beginning." This dissertation shows that retrofitting security does not… (more)

Subjects/Keywords: Security; Program Transformation

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Hafiz, M. (2011). Security on demand. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/18413

Chicago Manual of Style (16^th Edition):

Hafiz, Munawar. “Security on demand.” 2011. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/18413.

MLA Handbook (7^th Edition):

Hafiz, Munawar. “Security on demand.” 2011. Web. 28 Feb 2021.

Vancouver:

Hafiz M. Security on demand. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2011. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/18413.

Council of Science Editors:

Hafiz M. Security on demand. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2011. Available from: http://hdl.handle.net/2142/18413

University of Illinois – Urbana-Champaign

11. Luo, Qingzhou. Testing, runtime verification, and analysis of concurrent programs.

Degree: PhD, Computer Science, 2015, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/87955

► With the development of multi-core processors, concurrent programs are becoming more and more popular. Among several models, the multithreaded shared-memory model is the predominant programming… (more)

▼ With the development of multi-core processors, concurrent programs are becoming more and more popular. Among several models, the multithreaded shared-memory model is the predominant programming paradigm for developing concurrent programs. However, because of non-deterministic scheduling, multithreaded code is hard to develop and test. Concurrency bugs, such as data races, atomicity violations, and deadlocks, are hard to detect and fix in multithreaded programs. To test and verify multithreaded programs, two sets of techniques are needed. The first one is to enforce thread schedules and runtime properties efficiently. Being able to enforce desired thread schedules and runtime properties would greatly help developers to develop reliable multithreaded code. The second one is to explore the state space of multithreaded programs efficiently. Systematic state-space exploration could guarantee correctness for mul- tithreaded code, however, it is usually time consuming and thus infeasible in most cases. This dissertation presents several techniques to address challenges arising in testing and runtime verification of multithreaded programs. The first two techniques are the IMUnit framework for enforcing testing schedules and the EnforceMOP system for enforcing runtime properties for multithreaded programs. An experimental evaluation shows that our techniques can enforce thread schedules and runtime properties effectively and efficiently, and have their own advantages over existing techniques. The other techniques are the RV-Causal framework and the CAPP technique in the ReEx framework for efficient state-space exploration of multithreaded code. RV-Causal employs the idea of the maximal causal model for state-space exploration in a novel way to reduce the exploration cost, without losing the ability to detect certain types of concurrency bugs. The results show that RV-Causal outperforms existing techniques by finding concurrency bugs and exploring the entire state space much more efficiently. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (advisor), Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22Havelund%2C%20Klaus%22%29&pagesize-30">Havelund, Klaus (committee member).

Subjects/Keywords: Runtime verification; concurrency; testing

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Luo, Q. (2015). Testing, runtime verification, and analysis of concurrent programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/87955

Chicago Manual of Style (16^th Edition):

Luo, Qingzhou. “Testing, runtime verification, and analysis of concurrent programs.” 2015. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/87955.

MLA Handbook (7^th Edition):

Luo, Qingzhou. “Testing, runtime verification, and analysis of concurrent programs.” 2015. Web. 28 Feb 2021.

Vancouver:

Luo Q. Testing, runtime verification, and analysis of concurrent programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2015. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/87955.

Council of Science Editors:

Luo Q. Testing, runtime verification, and analysis of concurrent programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2015. Available from: http://hdl.handle.net/2142/87955

University of Illinois – Urbana-Champaign

12. Garg, Pranav. Learning-based inductive invariant synthesis.

Degree: PhD, Computer Science, 2015, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/88026

► The problem of synthesizing adequate inductive invariants to prove a program correct lies at the heart of automated program verification. We investigate, herein, learning approaches… (more)

▼ The problem of synthesizing adequate inductive invariants to prove a program correct lies at the heart of automated program verification. We investigate, herein, learning approaches to synthesize inductive invariants of sequential programs towards automatically verifying them. To this end, we identify that prior learning approaches were unduly influenced by traditional machine learning models that learned concepts from positive and negative counterexamples. We argue that these models are not robust for invariant synthesis and, consequently, introduce ICE, a robust learning paradigm for synthesizing invariants that learns using positive, negative and implication counterexamples, and show that it admits honest teachers and strongly convergent mechanisms for invariant synthesis. We develop the first learning algorithms in this model with implication counterexamples for two domains, one for learning arbitrary Boolean combinations of numerical invariants over scalar variables and one for quantified invariants of linear data-structures including arrays and dynamic lists. We implement the ICE learners and an appropriate teacher, and show that the resulting invariant synthesis is robust, practical, convergent, and efficient. In order to deductively verify shared-memory concurrent programs, we present a sequentialization result and show that synthesizing rely-guarantee annotations for them can be reduced to invariant synthesis for sequential programs. Further, for verifying asynchronous event-driven systems, we develop a new invariant synthesis technique that constructs almost-synchronous invariants over concrete system configurations. These invariants, for most systems, are finitely representable, and can be thereby constructed, including for the USB driver that ships with Microsoft Windows phone. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (advisor), Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Viswanathan%2C%20Mahesh%22%29&pagesize-30">Viswanathan, Mahesh (committee member), Champaign%22%20%2Bcontributor%3A%28%22Gulwani%2C%20Sumit%22%29&pagesize-30">Gulwani, Sumit (committee member), Champaign%22%20%2Bcontributor%3A%28%22McMillan%2C%20Kenneth%22%29&pagesize-30">McMillan, Kenneth (committee member).

Subjects/Keywords: verification; invariants; invariant synthesis; learning; machine learning; learning invariants using Implication Counter-Examples (ICE) learning model

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Garg, P. (2015). Learning-based inductive invariant synthesis. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/88026

Chicago Manual of Style (16^th Edition):

Garg, Pranav. “Learning-based inductive invariant synthesis.” 2015. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/88026.

MLA Handbook (7^th Edition):

Garg, Pranav. “Learning-based inductive invariant synthesis.” 2015. Web. 28 Feb 2021.

Vancouver:

Garg P. Learning-based inductive invariant synthesis. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2015. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/88026.

Council of Science Editors:

Garg P. Learning-based inductive invariant synthesis. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2015. Available from: http://hdl.handle.net/2142/88026

University of Illinois – Urbana-Champaign

13. Sorrentino, Francesco. Algorithmic techniques for predictive testing of concurrent programs and distributed systems.

Degree: PhD, 0112, 2014, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/49713

► The rise of multicore hardware platforms has lead to a new era of computing. In order to take full advantage of the power of multicore… (more)

▼ The rise of multicore hardware platforms has lead to a new era of computing. In order to take full advantage of the power of multicore processors, developers need to write concurrent code. Unfortunately, as a result of the non-determinism introduced by thread scheduling, multi-threaded programs can show different behaviors even for a single input. Errors in concurrent programs often occur under subtle interleaving patterns that the programmer had not foreseen. There are too many interleavings to explore, even on a fixed test input for a concurrent program, making concurrency testing a hard problem. Current testing technologies such as stress testing (running the program under test repeatedly with randomized sleep statements and by varying parameters on different platforms) have proved largely inadequate in exposing such subtle interleavings. Among the various techniques to test concurrent programs, the prediction-based technique is one of most valuable technology. Starting from one arbitrary concurrent execution of the program under testing, alternate interleavings that are likely to contain bugs are predicted. In our research, we explore prediction algorithms based on a combination of static analysis and logical constraint solving to efficiently and effectively test concurrent programs. The strength of our research lies in the fact that the techniques we propose are general enough to predict, with a high degree of accuracy of feasibility, various kinds of concurrent errors. We provide evidence that such an approach is promising in testing concurrent programs. In fact, we have implemented our techniques in a framework, Penelope. We evaluate it over benchmark programs and find scores of null-pointer dereferences, data-races, atomicity violations and deadlocks by using only a single test run as the prediction seed for each benchmark. We also take into account the challenge of bringing our experience in predictive testing of concurrent programs to the distributed systems environment. We use supervised machine learning to model the system behaviors in response to perturbations, based on recorded observations in a pseudo distributed (small-scale) setting. From the learned model, we predict the next system state given current states and applied perturbations. In a perturbation-based testing framework, accurate prediction helps to shorten the waiting time between the consecutive perturbations. Moreover, from the learned model, we reconstruct a possible sequence of perturbation from a given sequence of observed system states for diagnosis. We demonstrate the usefulness of our approach in a case study of a distributed system based on ZooKeeper and SolrCloud. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (advisor), Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Ro%C3%85%C2%9Fu%2C%20Grigore%22%29&pagesize-30">Roşu, Grigore (committee member), Champaign%22%20%2Bcontributor%3A%28%22Qadeer%2C%20Shaz%22%29&pagesize-30">Qadeer, Shaz (committee member).

Subjects/Keywords: Testing; Concurrency; Cloud; Diagnosis; Bugs; Data-Race; Deadlock; Null-Pointer; Atomicity

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Sorrentino, F. (2014). Algorithmic techniques for predictive testing of concurrent programs and distributed systems. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/49713

Chicago Manual of Style (16^th Edition):

Sorrentino, Francesco. “Algorithmic techniques for predictive testing of concurrent programs and distributed systems.” 2014. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/49713.

MLA Handbook (7^th Edition):

Sorrentino, Francesco. “Algorithmic techniques for predictive testing of concurrent programs and distributed systems.” 2014. Web. 28 Feb 2021.

Vancouver:

Sorrentino F. Algorithmic techniques for predictive testing of concurrent programs and distributed systems. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2014. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/49713.

Council of Science Editors:

Sorrentino F. Algorithmic techniques for predictive testing of concurrent programs and distributed systems. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2014. Available from: http://hdl.handle.net/2142/49713

University of Illinois – Urbana-Champaign

14. Muzahid, Abdullah. Effective architectural support for detecting concurrency bugs.

Degree: PhD, 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/34513

► Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. Therefore, it… (more)

▼ Multicore machines have become pervasive and, as a result, parallel programming has received renewed interest. Unfortunately, writing correct parallel programs is notoriously hard. Therefore, it is important to innovate with techniques and approaches to tackle various types of concurrency bugs. This thesis aims at making parallel programming easier by detecting some of the most common and difficult concurrency bugs in shared memory parallel programs, namely data races, atomicity violations, and sequential consistency violations. Specifically, we propose novel, effective and efficient hardware-based techniques that help detect and isolate these bugs. We use hardware-based solutions because they lead to low overhead solutions. Therefore we can use these techniques to detect the bugs both during development time and during production run. The proposal to detect data races is called SigRace. It uses hardware address signatures to detect data races dynamically at run time. As a processor runs, the addresses of the data that it accesses are automatically encoded in signatures. At certain times, the signatures are automatically passed to a hardware module that intersects them with those of other processors. If the intersection is not null, a data race may have occurred, in which case we run a more detailed analysis to pinpoint the race. SigRace can detect data races successfully. But even if a multithreaded program does not have any data races, it can still show incorrect behavior because of a bug named atomicity violation. The proposal to detect atomicity violations is called AtomTracker. It is based on first trying to learn atomicity constraints automatically from the program, by analyzing many correct executions. After it finds the set of possible atomic regions, the hardware monitors the execution to detect any violations of these atomic regions. AtomTracker uses a hardware very similar to SigRace to accomplish this. The above approaches tackle data races in a classical sense or in a more higher level sense (namely atomicity violations). The last work of this thesis is to find out a special pattern of data races that are particularly hard to detect and analyze. This complicated pattern of data races leads to violation of sequential consistency which is the underlying behavior of the memory model that programmers usually assume. Sequential consistency violations (SCV) lead to some of the most notorious bugs in parallel programs. In order to detect SCV in a machine with a relaxed memory model, we leverage cache coherence protocol transactions and dynamically detect cycles in memory-access orderings across threads. When one such cycle is about to occur, an exception is triggered, providing the exact architectural state. We performed detailed experimentation with each of these techniques and showed that they are effective in detecting various types of concurrency bugs. More importantly, we uncovered several new and previously unreported bugs in various popular open… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (advisor), Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Snir%2C%20Marc%22%29&pagesize-30">Snir, Marc (committee member), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22King%2C%20Samuel%20T.%22%29&pagesize-30">King, Samuel T. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Frank%2C%20Matthew%20I.%22%29&pagesize-30">Frank, Matthew I. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Peterson%2C%20Paul%20E.%22%29&pagesize-30">Peterson, Paul E. (committee member).

Subjects/Keywords: Debugging; Concurrency Bugs; Multithreaded Programs; Multicore

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Muzahid, A. (2012). Effective architectural support for detecting concurrency bugs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/34513

Chicago Manual of Style (16^th Edition):

Muzahid, Abdullah. “Effective architectural support for detecting concurrency bugs.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/34513.

MLA Handbook (7^th Edition):

Muzahid, Abdullah. “Effective architectural support for detecting concurrency bugs.” 2012. Web. 28 Feb 2021.

Vancouver:

Muzahid A. Effective architectural support for detecting concurrency bugs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/34513.

Council of Science Editors:

Muzahid A. Effective architectural support for detecting concurrency bugs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/34513

University of Illinois – Urbana-Champaign

15. Yasmeen, Ayesha. Formalizing operator task analysis.

Degree: PhD, 0112, 2011, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/26103

► Human operators are unique in their decision making capability, judgment and nondeterminism. Their sense of judgment, unpredictable decision procedures, susceptibility to environmental elements can cause… (more)

▼ Human operators are unique in their decision making capability, judgment and nondeterminism. Their sense of judgment, unpredictable decision procedures, susceptibility to environmental elements can cause them to erroneously execute a given task description to operate a computer system. Usually, a computer system is protected against some erroneous human behaviors by having necessary safeguard mechanisms in place. But some erroneous human operator behaviors can lead to severe or even fatal consequences especially in safety critical systems. A generalized methodology that can allow modeling and analyzing the interactions between computer systems and human operators where the operators are allowed to deviate from their prescribed behaviors will provide a formal understanding of the robustness of a computer system against possible aberrant behaviors by its human operators. We provide several methodology for assisting in modeling and analyzing human behaviors exhibited while operating computer systems. Every human operator is usually given a specific recommended set of guidelines for operating a system. We first present process algebraic methodology for modeling and verifying recommended human task execution behavior. We present how one can perform runtime monitoring of a computer system being operated by a human operator for checking violation of temporal safety properties. We consider the concept of a protection envelope giving a wider class of behaviors than those strictly prescribed by a human task that can be tolerated by a system. We then provide a framework for determining whether a computer system can maintain its guarantees if the human operators operate within their protection envelopes. This framework also helps to determine the robustness of the computer system under weakening of the protection envelopes. In this regard, we present a tool called Tutela that assists in implementing the framework. We then examine the ability of a system to remain safe under broad classes of variations of the prescribed human task. We develop a framework for addressing two issues. The first issue is: given a human task specification and a protection envelope, will the protection envelope properties still hold under standard erroneous executions of that task by the human operators? In other words how robust is the protection envelope? The second issue is: in the absence of a protection envelope, can we approximate a protection envelope encompassing those standard erroneous human behaviors that can be safely endured by the system? We present an extension of Tutela that implements this framework. The two frameworks mentioned above use Concurrent Game Structures (CGS) as models for both computer systems and their human operators. However, there are some shortcomings of this formalism for our uses. We add incomplete information concepts in CGSs to achieve better modularity for the players. We introduce nondeterminism in both the transition system and strategies of players and in the modeling of human operators and computer… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Gunter%2C%20Elsa%20L.%22%29&pagesize-30">Gunter, Elsa L. (advisor), Champaign%22%20%2Bcontributor%3A%28%22Gunter%2C%20Elsa%20L.%22%29&pagesize-30">Gunter, Elsa L. (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Gunter%2C%20Carl%20A.%22%29&pagesize-30">Gunter, Carl A. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Ro%C3%85%C2%9Fu%2C%20Grigore%22%29&pagesize-30">Roşu, Grigore (committee member), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Johnson%2C%20Ralph%20E.%22%29&pagesize-30">Johnson, Ralph E. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Clarke%2C%20Lori%20A.%22%29&pagesize-30">Clarke, Lori A. (committee member).

Subjects/Keywords: human operators; system verification; task analysis; human error; formal methods; model checking; runtime monitoring; reliability; Model theory; temporal logic; model refinement; requirement satisfaction; system robustness; protected task execution; incomplete information; concurrent game structures; formal human behavior model; tolerance of erroneous human behaviors

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Yasmeen, A. (2011). Formalizing operator task analysis. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/26103

Chicago Manual of Style (16^th Edition):

Yasmeen, Ayesha. “Formalizing operator task analysis.” 2011. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/26103.

MLA Handbook (7^th Edition):

Yasmeen, Ayesha. “Formalizing operator task analysis.” 2011. Web. 28 Feb 2021.

Vancouver:

Yasmeen A. Formalizing operator task analysis. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2011. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/26103.

Council of Science Editors:

Yasmeen A. Formalizing operator task analysis. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2011. Available from: http://hdl.handle.net/2142/26103

16. Kirn, Mathew. Evaluating machine-independent metrics for state-space exploration.

Degree: MS, 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/29796

► Many recent advancements in testing concurrent programs have surfaced as novel optimization and heuristic techniques in tools that explore the state spaces of tests for… (more)

▼ Many recent advancements in testing concurrent programs have surfaced as novel optimization and heuristic techniques in tools that explore the state spaces of tests for such programs. To empirically evaluate these techniques, researchers apply them on subject programs, capture a set of metrics, and compare these metrics to provide some measure of the techniques??? effectiveness. From a user???s perspective, the metric that best measures effectiveness is the amount of real time to find a bug (if one exists), but using real time for comparison can produce misleading results because it is necessarily dependent on the configuration of the machine used (i.e., hardware, OS, etc.). The metrics used in evaluations in the literature often vary widely and are either machine-independent (e.g., number of states, transitions, paths) or machine-dependent (e.g., real time, memory), and are captured using a variety of machine configurations ranging from a single machine to a cluster of machines. Depending upon the machine configuration(s) and metric(s) selected for a particular evaluation, the results may suggest different conclusions, and the experiments may be difficult to repeat. As a result, it can be difficult to perform meaningful comparisons for state-space exploration tools and the techniques they employ. This thesis provides a study of the usefulness of different metrics and machine configurations for two different state-space exploration frameworks for Java, JPF (stateful) and ReEx (stateless), by revisiting and extending a previous study (Parallel Randomized State-Space Search) and evaluating the correlation of several machine-independent metrics with real time. We have conducted a set of experiments across both previously used and new subject programs in order to evaluate the degree to which several machine-independent metrics correlate with real time both on a single machine and on a high-performance cluster of machines. We provide new evidence for selecting metrics in future evaluations of state-space exploration techniques by showing that several machine-independent metrics for state-space exploration are a good substitute for real time, and that reporting real time results even from clusters of machines can provide useful information. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor).

Subjects/Keywords: State Space; Exploration; Concurrency; Metrics

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Kirn, M. (2012). Evaluating machine-independent metrics for state-space exploration. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/29796

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Kirn, Mathew. “Evaluating machine-independent metrics for state-space exploration.” 2012. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/29796.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Kirn, Mathew. “Evaluating machine-independent metrics for state-space exploration.” 2012. Web. 28 Feb 2021.

Vancouver:

Kirn M. Evaluating machine-independent metrics for state-space exploration. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/29796.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Kirn M. Evaluating machine-independent metrics for state-space exploration. [Thesis]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/29796

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

17. Sharma, Rohan. Guidelines for coverage-based comparisons of non-adequate test suites.

Degree: MS, 0112, 2014, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/46636

► A fundamental question in software testing research is how to compare test suites, often as a means for comparing test-generation techniques that produce those test… (more)

▼ A fundamental question in software testing research is how to compare test suites, often as a means for comparing test-generation techniques that produce those test suites. Researchers frequently compare test suites by measuring their coverage. A coverage criterion C provides a set of test requirements and measures how many requirements a given suite satisfies. A suite that satisfies 100% of the (feasible) requirements is called C-adequate. Previous rigorous evaluations of coverage criteria mostly focused on such adequate test suites: given two criteria C and C′, are C-adequate suites (on average) more effective than C′-adequate suites? However, in many realistic cases, producing adequate suites is impractical or even impossible. This thesis presents the first extensive study that evaluates coverage criteria for the com- mon case of non-adequate test suites: given two criteria C and C′, which one is better to use to compare test suites? Namely, if suites T1, T2,...,Tn have coverage values c1,c2,...,cn for C and c′1,c2,...,c′n for C′, is it better to compare suites based on c1,c2,...,cn or based on c′1,c2,...,c′n? This thesis evaluates a large set of plausible criteria, including basic criteria such as statement and branch coverage, as well as stronger criteria used in recent studies, including criteria based on program paths, equivalence classes of covered statements, and predicate states. The criteria are evaluated on a set of Java and C programs with both manually written and automatically generated test suites. The evaluation uses three correlation measures. Based on these experiments, two criteria perform best: branch coverage and an intra-procedural acyclic path coverage. We provide guidelines for testing researchers aiming to evaluate test suites using coverage criteria as well as for other researchers evaluating coverage criteria for research use. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Caesar%2C%20Matthew%20C.%22%29&pagesize-30">Caesar, Matthew C. (advisor).

Subjects/Keywords: Coverage criteria; non-adequate test suites

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Sharma, R. (2014). Guidelines for coverage-based comparisons of non-adequate test suites. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/46636

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Sharma, Rohan. “Guidelines for coverage-based comparisons of non-adequate test suites.” 2014. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/46636.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Sharma, Rohan. “Guidelines for coverage-based comparisons of non-adequate test suites.” 2014. Web. 28 Feb 2021.

Vancouver:

Sharma R. Guidelines for coverage-based comparisons of non-adequate test suites. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2014. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/46636.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Sharma R. Guidelines for coverage-based comparisons of non-adequate test suites. [Thesis]. University of Illinois – Urbana-Champaign; 2014. Available from: http://hdl.handle.net/2142/46636

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

18. Tan, Shin Hwei. @tComment: testing Javadoc comments to detect comment-code inconsistencies.

Degree: MS, 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/31123

► Code comments are important artifacts in software. Javadoc comments are widely used in Java for API specifications. API developers write Javadoc comments, and API users… (more)

Subjects/Keywords: comment analysis; random testing; test generation

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Tan, S. H. (2012). @tComment: testing Javadoc comments to detect comment-code inconsistencies. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/31123

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Tan, Shin Hwei. “@tComment: testing Javadoc comments to detect comment-code inconsistencies.” 2012. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/31123.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Tan, Shin Hwei. “@tComment: testing Javadoc comments to detect comment-code inconsistencies.” 2012. Web. 28 Feb 2021.

Vancouver:

Tan SH. @tComment: testing Javadoc comments to detect comment-code inconsistencies. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/31123.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Tan SH. @tComment: testing Javadoc comments to detect comment-code inconsistencies. [Thesis]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/31123

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

19. Gyori, Alex. Proactively detecting unreliable tests.

Degree: PhD, Computer Science, 2017, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/98348

► Regression testing is the most wide-spread method to ensure the quality of software systems. Whenever a change is made to the software, tests are run… (more)

▼ Regression testing is the most wide-spread method to ensure the quality of software systems. Whenever a change is made to the software, tests are run to ensure bugs are not introduced: if all tests pass, the change is merged into the codebase; otherwise, the developer needs to identify the bug that was introduced by the change. Developers assume that the outcomes of the tests in the regression testing process are reliable, i.e., that the failure indicates a bug introduced by the change. Unfortunately, unreliable tests manage to get into the test suite, slowing down the developers’ workflow and having developers debug not their software but rather the test code or infrastructure. This dissertation presents two techniques to enable developers to more easily and proactively detect and debug unreliable tests early, before they become a problem and slow down the development process. Developers write unreliable tests, which may pass on their machine but may at a later point fail because the environment changes. This dissertation presents a technique to detect when code makes wrong assumptions on underdetermined APIs. While these assumptions may hold in the current environment, they may not hold in the future, causing tests to fail. The technique, NonDex, detects such wrong assumptions by exploring different behaviors that may not manifest in the current implementation, but are allowed by the specification. Furthermore, the dissertation presents PolDet, a technique to detect when tests pollute their environment; such polluting tests can cause other tests to fail or pass seemingly nondeterministically because of the environment pollution rather than changes in the code. The two techniques enable developers to identify when they are introducing unreliability in their test suite and help identify the root causes of the unreliable tests. The results of the evaluation on open-source projects show the techniques are effective at identifying issues in open-source code and also that developers are eager to fix the issues and adopt the tools. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22Lahiri%2C%20Shuvendu%20K%22%29&pagesize-30">Lahiri, Shuvendu K (committee member).

Subjects/Keywords: Unreliable tests; Flaky tests; Proactive detection

3 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Gyori, A. (2017). Proactively detecting unreliable tests. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/98348

Chicago Manual of Style (16^th Edition):

Gyori, Alex. “Proactively detecting unreliable tests.” 2017. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/98348.

MLA Handbook (7^th Edition):

Gyori, Alex. “Proactively detecting unreliable tests.” 2017. Web. 28 Feb 2021.

Vancouver:

Gyori A. Proactively detecting unreliable tests. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2017. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/98348.

Council of Science Editors:

Gyori A. Proactively detecting unreliable tests. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2017. Available from: http://hdl.handle.net/2142/98348

20. Jagannath, Vilas. Improved regression testing of multithreaded programs.

Degree: PhD, 0112 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/31093

► 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… (more)

▼ 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. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%20A.%22%29&pagesize-30">Agha, Gul A. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Ro%C3%85%C2%9Fu%2C%20Grigore%22%29&pagesize-30">Roşu, Grigore (committee member), Champaign%22%20%2Bcontributor%3A%28%22Hind%2C%20Michael%22%29&pagesize-30">Hind, Michael (committee member).

Subjects/Keywords: mutithreaded; regression testing; unit testing; IMUnit; Change-Aware Preemption Prioritization (CAPP)

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Jagannath, V. (2012). Improved regression testing of multithreaded programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/31093

Chicago Manual of Style (16^th Edition):

Jagannath, Vilas. “Improved regression testing of multithreaded programs.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/31093.

MLA Handbook (7^th Edition):

Jagannath, Vilas. “Improved regression testing of multithreaded programs.” 2012. Web. 28 Feb 2021.

Vancouver:

Jagannath V. Improved regression testing of multithreaded programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/31093.

Council of Science Editors:

Jagannath V. Improved regression testing of multithreaded programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/31093

21. Gligoric, Milos Zivko. Regression test selection: theory and practice.

Degree: PhD, Computer Science, 2015, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/88038

► Software affects every aspect of our lives, and software developers write tests to check software correctness. Software also rapidly evolves due to never-ending requirement changes,… (more)

▼ Software affects every aspect of our lives, and software developers write tests to check software correctness. Software also rapidly evolves due to never-ending requirement changes, and software developers practice regression testing – running tests against the latest project revision to check that project changes did not break any functionality. While regression testing is important, it is also time-consuming due to the number of both tests and revisions. Regression test selection (RTS) speeds up regression testing by selecting to run only tests that are affected by project changes. RTS is efficient if the time to select tests is smaller than the time to run unselected tests; RTS is safe if it guarantees that unselected tests cannot be affected by the changes; and RTS is precise if tests that are not affected are also unselected. Although many RTS techniques have been proposed in research, these techniques have not been adopted in practice because they do not provide efficiency and safety at once. This dissertation presents three main bodies of research to motivate, introduce, and improve a novel, efficient, and safe RTS technique, called Ekstazi. Ekstazi is the first RTS technique being adopted by popular open-source projects. First, this dissertation reports on the first field study of test selection. The study of logs, recorded in real time from a diverse group of developers, finds that almost all developers perform manual RTS, i.e., manually select to run a subset of tests at each revision, and they select these tests in mostly ad hoc ways. Specifically, the study finds that manual RTS is not safe 74% of the time and not precise 73% of the time. These findings showed the urgent need for a better automated RTS techniques that could be adopted in practice. Second, this dissertation introduces Ekstazi, a novel RTS technique that is efficient and safe. Ekstazi tracks dynamic dependencies of tests on files, and unlike most prior RTS techniques, Ekstazi requires no integration with version-control systems. Ekstazi computes for each test what files it depends on; the files can be either executable code or external resources. A test need not be run in the new project revision if none of its dependent files changed. This dissertation also describes an implementation of Ekstazi for the Java programming language and the JUnit testing framework, and presents an extensive evaluation of Ekstazi on 615 revisions of 32 open-source projects (totaling almost 5M lines of code) with shorter- and longer-running test suites. The results show that Ekstazi reduced the testing time by 32% on average (and by 54% for longer-running test suites) compared to executing all tests. Ekstazi also yields lower testing time than the existing RTS techniques, despite the fact that Ekstazi may select more tests. Ekstazi is the first RTS tool adopted by several popular open-source projects, including Apache Camel, Apache Commons Math, and Apache CXF. Third, this dissertation presents a novel approach that improves precision of any RTS technique… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Ro%C3%85%C2%9Fu%2C%20Grigore%22%29&pagesize-30">Roşu, Grigore (committee member), Champaign%22%20%2Bcontributor%3A%28%22Torrellas%2C%20Josep%22%29&pagesize-30">Torrellas, Josep (committee member), Champaign%22%20%2Bcontributor%3A%28%22Khurshid%2C%20Sarfraz%22%29&pagesize-30">Khurshid, Sarfraz (committee member), Champaign%22%20%2Bcontributor%3A%28%22Majumdar%2C%20Rupak%22%29&pagesize-30">Majumdar, Rupak (committee member).

Subjects/Keywords: Regression test selection; Regression testing; Ekstazi; Distributed software histories

2 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Gligoric, M. Z. (2015). Regression test selection: theory and practice. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/88038

Chicago Manual of Style (16^th Edition):

Gligoric, Milos Zivko. “Regression test selection: theory and practice.” 2015. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/88038.

MLA Handbook (7^th Edition):

Gligoric, Milos Zivko. “Regression test selection: theory and practice.” 2015. Web. 28 Feb 2021.

Vancouver:

Gligoric MZ. Regression test selection: theory and practice. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2015. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/88038.

Council of Science Editors:

Gligoric MZ. Regression test selection: theory and practice. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2015. Available from: http://hdl.handle.net/2142/88038

22. Lauterburg, Steven T. Systematic testing for actor programs.

Degree: PhD, 0112, 2011, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/26314

► The growing use of multicore and networked computing systems is increasing the importance of developing reliable parallel and distributed code. Testing such code is notoriously… (more)

▼ The growing use of multicore and networked computing systems is increasing the importance of developing reliable parallel and distributed code. Testing such code is notoriously difficult, especially for shared-memory models of programming. The actor model of programming offers a promising alternative for developing concurrent systems based on message passing. In actor-based systems, shared-memory access is not allowed, and the key source of non-determinism is the order in which messages are delivered to and processed by the actors. As a result, errors may occur in actor programs due to the incorrect interleaving of messages, conflicting constraints on what messages can be delivered, or errors in the sequential code within individual actors. The research community has expended a great deal of effort on the testing and verification of concurrent systems. However, much of this effort has been general in nature or focused on shared-memory models. Given the differences in how errors manifest in actor programs, it seems natural that tools and techniques for testing such programs should take into account the particular nature of the actor model. To effectively and efficiently automate the detection of these errors, we propose a set of tools and techniques specifically designed to systematically explore the different behaviors of actor programs resulting from possible message delivery schedules. Specifically, this dissertation presents Basset, a general framework for the systematic testing of actor systems developed with languages that compile to Java bytecode. This framework provides a common set of capabilities designed and implemented to take advantage of actor semantics. By building these capabilities into a language-independent core, they are available for use by any instantiation of the framework. This dissertation illustrates the practicality and effectiveness of this approach by presenting two tool instantiations of the Basset framework: one for the Scala programming language and the other for the ActorFoundry library for Java. The implementation of Basset was built as an extension to Java PathFinder, a popular model checker for Java, in order to leverage capabilities that already exist in that model checker. The Basset framework approach directly enables the relatively quick development of testing environments for actor-based languages and/or libraries that compile to Java bytecode. This dissertation also considers the effectiveness of dynamic partial-order reduction techniques as they relate to the exploration of actor programs. The use of dynamic partial-order reduction speeds up systematic testing by pruning parts of the exploration space. However, the level of potential pruning is highly dependent on the order in which messages are considered for processing. This dissertation presents an evaluation of a number of heuristics for choosing the order in which messages are explored in Basset. The experiments show that the choice of heuristic can affect the number of execution paths that need to be explored by… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%20A.%22%29&pagesize-30">Agha, Gul A. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Viswanathan%2C%20Mahesh%22%29&pagesize-30">Viswanathan, Mahesh (committee member), Champaign%22%20%2Bcontributor%3A%28%22Johnson%2C%20Ralph%20E.%22%29&pagesize-30">Johnson, Ralph E. (committee member).

Subjects/Keywords: systematic testing; concurrency; actor model; message passing; partial-order reduction; model checking

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Lauterburg, S. T. (2011). Systematic testing for actor programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/26314

Chicago Manual of Style (16^th Edition):

Lauterburg, Steven T. “Systematic testing for actor programs.” 2011. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/26314.

MLA Handbook (7^th Edition):

Lauterburg, Steven T. “Systematic testing for actor programs.” 2011. Web. 28 Feb 2021.

Vancouver:

Lauterburg ST. Systematic testing for actor programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2011. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/26314.

Council of Science Editors:

Lauterburg ST. Systematic testing for actor programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2011. Available from: http://hdl.handle.net/2142/26314

23. Legunsen, Owolabi. Evolution-aware runtime verification.

Degree: PhD, Computer Science, 2019, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/106225

► The risk posed by software bugs has increased tremendously as software is now essential to many aspects of our daily lives. Software testing is still… (more)

▼ The risk posed by software bugs has increased tremendously as software is now essential to many aspects of our daily lives. Software testing is still the most common method for finding bugs during software development, before software is deployed. However, software testing alone is insufficient for finding bugs, as evidenced by the many devastating bugs that frequently manifest in deployed software. Hence, there is a great need to investigate how to use formal-methods based approaches effectively and efficiently during software testing, to help find more bugs during software development. This dissertation presents work on finding more bugs during software development by performing runtime verification during software testing. Runtime verification can help find bugs by monitoring program executions against formally specified properties. Over the last two decades, great research progress has improved the performance of runtime verification, but mostly focused on deployed software. There was little focus on the bug-finding benefits and scalability challenges of using runtime verification during testing of evolving software. Yet, software testing generates many executions on which properties can be monitored to squeeze more bug-finding value from existing tests. This dissertation presents two lines of work on studying and improving the use of runtime verification for finding more bugs during testing of evolving software. Firstly, this dissertation reports on the first large-scale study of runtime verification during software testing. The study performs runtime verification using 199 properties while running 18K developer written tests and 2.1M automatically generated tests in 200 open-source projects. Results show that runtime verification during software testing finds many bugs from existing tests, but incurs high overhead. In spite of tremendous recent research and algorithmic advances in the runtime verification community on improving the runtime overhead, user experience, and monitored properties, runtime overhead was still as high as 33.9x, many property violations were generated that had to be manually inspected, and 84% of the inspected violations were not bugs due to the ineffectiveness of current properties. Secondly, this dissertation proposes the idea of, and implements the first set of techniques for, reducing the overhead of runtime verification during software testing by exploiting software evolution. All prior runtime verification research focused on checking a single version of software. The proposed evolution-aware techniques extend runtime verification to support multiple software versions and make runtime verification more usable during software evolution. The key insight behind the evolution-aware techniques is to amortize the overhead of runtime verification across multiple versions by only monitoring the parts of code that changed between versions. Results show that evolution-aware techniques reduce the accumulated runtime verification overhead by up to 10x and show developers two orders of… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (advisor), Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (advisor), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22Khurshid%2C%20Sarfraz%22%29&pagesize-30">Khurshid, Sarfraz (committee member).

Subjects/Keywords: Runtime Verification; Software Evolution; Regression Testing; Software Engineering; Formal Methods; STARTS

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Legunsen, O. (2019). Evolution-aware runtime verification. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/106225

Chicago Manual of Style (16^th Edition):

Legunsen, Owolabi. “Evolution-aware runtime verification.” 2019. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/106225.

MLA Handbook (7^th Edition):

Legunsen, Owolabi. “Evolution-aware runtime verification.” 2019. Web. 28 Feb 2021.

Vancouver:

Legunsen O. Evolution-aware runtime verification. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2019. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/106225.

Council of Science Editors:

Legunsen O. Evolution-aware runtime verification. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2019. Available from: http://hdl.handle.net/2142/106225

24. Lin, Yu. Automated refactoring for Java concurrency.

Degree: PhD, Computer Science, 2015, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/88945

► In multicore era, programmers exploit concurrent programming to gain performance and responsiveness benefits. However, concurrent programs are difficult to write: the programmer has to balance… (more)

▼ In multicore era, programmers exploit concurrent programming to gain performance and responsiveness benefits. However, concurrent programs are difficult to write: the programmer has to balance two conflicting forces, thread safety and performance. To make concurrent programming easier, modern programming languages provide many kinds of concurrent constructs, such as threads, asynchronous tasks, concurrent collections, etc. However, despite the existence of these concurrent constructs, we know little about how developers use them. On the other hand, although existing API documentation teach developers how to use concurrent constructs, developers can still misuse and underuse them. In this dissertation, we study the use, misuse, and underuse of two types of commonly used Java concurrent constructs: Java concurrent collections and Android async constructs. Our studies show that even though concurrent constructs are widely used in practice, developers still misuse and underuse them, causing semantic and performance bugs. We propose and develop a refactoring toolset to help developers correctly use concurrent constructs. The toolset is composed of three automated refactorings: (i) detecting and fixing the misuses of Java concurrent collections, (ii) retro fitting concurrency for existing sequential Android code via a basic Android async construct, and (iii) converting inappropriately used basic Android async constructs to appropriately enhanced constructs for Android apps. Refactorings (i) and (iii) aim to fix misused constructs while refactoring (ii) aims to eliminate underuses. First, we cataloged nine commonly misused check-then-act idioms of Java concurrent collections, and show the correct usage of each idiom. We implemented the detection strategies in a tool, CTADetector, that finds and fi xes misused check-then-act idioms. We applied CTADetector to 28 widely used open source Java projects (comprising 6.4 million lines of code) that use Java concurrent collections. CTADetector discovered and fixed 60 bugs. These bugs were con firmed by developers and the fixes were accepted. Second, we conducted a formative study on how a basic Android async construct, AsyncTask, is used, misused, and underused in Android apps. Based on the study, we designed, developed, and evaluated Asynchronizer, an automated refactoring tool that enables developers to retrofit concurrency into Android apps. The refactoring uses a points-to static analysis to determine the safety of the refactoring. We applied Asynchronizer to perform 123 refactorings in 19 widely used Android apps; their developers accepted 40 refactorings in 7 projects. Third, we conducted a formative study on a corpus of 611 widely-used Android apps to map the asynchronous landscape of Android apps, understand how developers retrofi t concurrency in Android apps, and learn about barriers encountered by developers. Based on this study, we designed, implemented, and evaluated AsyncDroid, a refactoring tool which enables Android developers to transform… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Dig%2C%20Daniel%22%29&pagesize-30">Dig, Daniel (advisor), Champaign%22%20%2Bcontributor%3A%28%22Dig%2C%20Daniel%22%29&pagesize-30">Dig, Daniel (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22Ivancic%2C%20Franjo%22%29&pagesize-30">Ivancic, Franjo (committee member).

Subjects/Keywords: Concurrency and Asynchrony; Empirical Study; Android; Concurrent Collections; Refactoring; Atomicity Violation

12 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Lin, Y. (2015). Automated refactoring for Java concurrency. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/88945

Chicago Manual of Style (16^th Edition):

Lin, Yu. “Automated refactoring for Java concurrency.” 2015. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/88945.

MLA Handbook (7^th Edition):

Lin, Yu. “Automated refactoring for Java concurrency.” 2015. Web. 28 Feb 2021.

Vancouver:

Lin Y. Automated refactoring for Java concurrency. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2015. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/88945.

Council of Science Editors:

Lin Y. Automated refactoring for Java concurrency. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2015. Available from: http://hdl.handle.net/2142/88945

25. Okur, Semih. Enabling modern concurrency through program transformations.

Degree: PhD, Computer Science, 2016, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/95354

► Concurrency is becoming the norm in modern software because multicores are now everywhere. Developers use concurrency constructs (i) to make their software responsive and scalable… (more)

▼ Concurrency is becoming the norm in modern software because multicores are now everywhere. Developers use concurrency constructs (i) to make their software responsive and scalable via asynchrony and (ii) to increase the throughput of their software via parallelism. Yet, we know little about how developers use these constructs in practice. Without such knowledge, (i) other developers cannot educate themselves about the state of the practice, (ii) language and library designers are unaware of any misuse, (iii) researchers make wrong assumptions, and (iv) tool providers do not provide the tools that developers really need. We claim that concurrent programming deserves first-class citizenship in empirical research and tool support. In this dissertation, we study the use, misuse, and underuse of concurrency constructs for C#. Based on our large-scale empirical studies, we found two main problems. First, developers still use complex, slow, low-level, and old constructs. Second, when developers use modern concurrency constructs, they highly misuse them, causing severe consequences such as subtle data-races and swallowed exceptions. Some significantly degrade the performance of async programs or can even deadlock the program. Other misuses make developers erroneously think that their code runs sequentially, when in reality the code runs concurrently; this causes unintended behavior and wrong results. This dissertation presents four tools to enable C# developers (i) to migrate their software to modern concurrency constructs and (ii) to fix misused modern constructs. First, we present an automated migration tool, Taskifier, that transforms old style Thread and ThreadPool constructs to higher-level Task constructs. Second, we present a refactoring tool, Simplifier, that extracts and converts Task-related code snippets into higher-level parallel patterns. Third, we provide Asyncifier to developers who want to refactor their callback-based asynchronous constructs to new async/await keywords. Fourth, we developed AsyncFixer, a static analysis tool that detects and corrects 14 common kinds of async/await misuses that cannot be detected by any existing tools. We released all our tools as plugins for the widely used Visual Studio IDE which has millions of users. We conducted both quantitative and qualitative evaluation of our tools. We applied the tools thousands of times over the real-world software and we show that they (i) are highly applicable, (ii) are much safer than manual transformations, and (iii) fast enough to be used interactively in Visual Studio. Our tools are useful in practice for both industry and open-source communities. Developers of the open-source software accepted 408 patches which are generated by the tools. We also received positive feedback from the early adopters. In industry, our tools are embraced by two companies. They started to actively use AsyncFixer in their automated build process. Our empirical findings have (i) educated thousands of developers through our educational web portals and (ii)… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Dig%2C%20Daniel%22%29&pagesize-30">Dig, Daniel (advisor), Champaign%22%20%2Bcontributor%3A%28%22Dig%2C%20Daniel%22%29&pagesize-30">Dig, Daniel (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Xie%2C%20Tao%22%29&pagesize-30">Xie, Tao (committee member), Champaign%22%20%2Bcontributor%3A%28%22van%20Deursen%2C%20Arie%22%29&pagesize-30">van Deursen, Arie (committee member).

Subjects/Keywords: concurrency; concurrent programming; empirical study; refactoring; program transformation; static analysis; asynchrony; parallelism; async/await; c#

9 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Okur, S. (2016). Enabling modern concurrency through program transformations. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/95354

Chicago Manual of Style (16^th Edition):

Okur, Semih. “Enabling modern concurrency through program transformations.” 2016. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/95354.

MLA Handbook (7^th Edition):

Okur, Semih. “Enabling modern concurrency through program transformations.” 2016. Web. 28 Feb 2021.

Vancouver:

Okur S. Enabling modern concurrency through program transformations. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2016. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/95354.

Council of Science Editors:

Okur S. Enabling modern concurrency through program transformations. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2016. Available from: http://hdl.handle.net/2142/95354

26. Jin, Dongyun. Making runtime monitoring of parametric properties practical.

Degree: PhD, 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/34333

► Software reliability has become more important than ever in recent years, as a wide spectrum of software solutions are being used on various platforms. To… (more)

▼ Software reliability has become more important than ever in recent years, as a wide spectrum of software solutions are being used on various platforms. To this end, runtime monitoring is one of the most promising and feasible solutions for enhancing software reliability. In particular, runtime monitoring of parametric properties (parametric monitoring) has been receiving growing attention for its suitability in object-oriented systems. Despite many parametric monitoring approaches that have been proposed recently, they are still not widely used in real applications, implying that parametric monitoring is not sufficiently practical yet. In this dissertation, three perspectives for better practicality of parametric monitoring are proposed: expressiveness, efficiency, and scalability. A number of techniques on all three perspectives are developed and integrated to the JavaMOP framework, which is a formalism-independent, extensible runtime monitoring framework for parametric properties. One limitation in expressing parametric properties is that the first event must alway initiate all parameters. This limitation is removed in the proposed work to improve expressiveness of parametric monitoring. Further, a new logical formalism, PTCaRet, is introduced for describing properties of the call stack. As for efficiency, the `enable set optimization', the `indexing cache', and the `monitor garbage collection' are proposed for optimizing creation of monitors, access to monitors, and termination of monitors, respectively. In addition, several scalable parametric monitoring techniques are introduced. These techniques, for the first time, allow a large number of simultaneous parametric specifications to be monitored efficiently. The optimization techniques presented in this dissertation were implemented into the JavaMOP framework, yielding JavaMOP 3.0, the latest and most efficient version of JavaMOP. Thorough evaluations show that these techniques can improve runtime performance of JavaMOP by 3 times on average, and up to 63 times in some cases; as for memory usage, by 3 times on average. While Tracematches and the previous version of JavaMOP crashed on several cases due to out of memory errors, the newer version of JavaMOP did not crash on any case during the evaluations. Considering that the previous version of JavaMOP was one of the most efficient parametric monitoring frameworks in terms of runtime performance, the results presented in the dissertation can be argued significant. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (advisor), Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Havelund%2C%20Klaus%22%29&pagesize-30">Havelund, Klaus (committee member), Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%20A.%22%29&pagesize-30">Agha, Gul A. (committee member), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member).

Subjects/Keywords: Runtime Monitoring; Parametric Monitoring; Optimization; Scalability; Monitoring Oriented Programming

7 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Jin, D. (2012). Making runtime monitoring of parametric properties practical. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/34333

Chicago Manual of Style (16^th Edition):

Jin, Dongyun. “Making runtime monitoring of parametric properties practical.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/34333.

MLA Handbook (7^th Edition):

Jin, Dongyun. “Making runtime monitoring of parametric properties practical.” 2012. Web. 28 Feb 2021.

Vancouver:

Jin D. Making runtime monitoring of parametric properties practical. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/34333.

Council of Science Editors:

Jin D. Making runtime monitoring of parametric properties practical. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/34333

27. Meredith, Patrick. Efficient, expressive, and effective runtime verification.

Degree: PhD, 0112, 2012, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/34253

► Runtime Verification is a quickly growing technique for providing many of the guarantees of formal verification, but in a manner that is scalable. It useful… (more)

▼ Runtime Verification is a quickly growing technique for providing many of the guarantees of formal verification, but in a manner that is scalable. It useful information available from actual runs of programs to make verification decisions, rather than the purely static information used in formal verification. One of the main facets of Runtime Verification is runtime monitoring, where safety properties are checked against the execution of a program during (or in some cases after) its run. Prior work on efficient monitoring focused primarily on finite state properties. Non-finite state techniques existed, but added orders of magnitude of runtime overhead on the monitored system. The vast majority of runtime monitoring has also been limited to the application domain, with violations of safety properties only found on the actual trace of a given program. This thesis describes research that demonstrates that various logical formalisms, including those more powerful than finite logics, can be efficiently monitored in multiple monitoring domains. The demonstrated monitoring domains run the gamut from the application level with the Java programming language, to monitoring traces \emph{predicted} from a given run of a program, to hardware based monitors designed to ensure proper peripheral operation. The logical formalisms include multicategory finite state machines, extended regular expressions, past-time linear temporal logic with optimization for hardware based monitors, context-free grammars, linear temporal logic with both past and future operators, and string rewriting. This combination of domains and logical formalisms show that monitoring can be both expressive and efficient, regardless of the expressive power of the logical formalism, and that monitoring can be used not only for flat traces generated by software applications, but also in predictive traces and a hardware context. Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (advisor), Champaign%22%20%2Bcontributor%3A%28%22Rosu%2C%20Grigore%22%29&pagesize-30">Rosu, Grigore (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Caccamo%2C%20Marco%22%29&pagesize-30">Caccamo, Marco (committee member), Champaign%22%20%2Bcontributor%3A%28%22Havelund%2C%20Klaus%22%29&pagesize-30">Havelund, Klaus (committee member), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member).

Subjects/Keywords: Runtime Verification; Software Engineering; Predictive Analysis; Runtime Monitoring; Runtime Monitoring Semantics

11 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Meredith, P. (2012). Efficient, expressive, and effective runtime verification. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/34253

Chicago Manual of Style (16^th Edition):

Meredith, Patrick. “Efficient, expressive, and effective runtime verification.” 2012. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/34253.

MLA Handbook (7^th Edition):

Meredith, Patrick. “Efficient, expressive, and effective runtime verification.” 2012. Web. 28 Feb 2021.

Vancouver:

Meredith P. Efficient, expressive, and effective runtime verification. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2012. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/34253.

Council of Science Editors:

Meredith P. Efficient, expressive, and effective runtime verification. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2012. Available from: http://hdl.handle.net/2142/34253

28. Li, Sihan. Whole-system testing and analysis of actor programs.

Degree: PhD, Computer Science, 2019, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/106237

► As multi-core processors and networked systems become the norm, concurrent programming has been widely adopted in industry. Practitioners have used concurrent programming models to build… (more)

▼ As multi-core processors and networked systems become the norm, concurrent programming has been widely adopted in industry. Practitioners have used concurrent programming models to build many complex and large-scale systems and infrastructures. With the growing popularity of concurrent programming, it is important to assure the reliability of concurrent systems. However, concurrent systems are notoriously difficult to understand, test, and debug, because the interleaving between concurrent processes leads to non-deterministic behaviors in the systems. The number of non-deterministic behaviors grows exponentially, making it challenging to test and analyze concurrent programs at the system level. In this dissertation, we target the problem of system testing and analysis of concurrent programs. We first present a characteristic study on real-world bugs in distributed data-processing production systems to identify common challenges and opportunities in reliability assurance of generic concurrent systems, and motivate the need of testing and analyzing the systems as a whole. Then we describe two solutions to the problem in the context of the Actor model, a popular concurrent programming model based on asynchronous message passing. Actors facilitate building scalable systems by making unintended race conditions and deadlocks less likely. Many large systems such as Twitter, LinkedIn, and Facebook Chat, as well as frameworks such as Microsoft Orleans have used the Actor model. In particular, we propose a target test generation method for effective testing of actor systems, and a behavioral specification inference method for understanding and analyzing actor systems. We conduct a comprehensive characteristic study on 200 production failures and their fixes in a distributed data processing system from Microsoft Bing. We investigate not only major failure types, failure sources, and fixes, but also the debugging practice. Our main findings include (1) one major type of failures is caused by defects in data processing due to frequent data schema changes and exceptional data; (2) another major type of failures is due to the non-determinism in the interactions between a group of concurrent processes; (3) detecting and diagnosing these bugs often requires system level testing and analysis, because in many cases, the root cause of the failure lies in a different process from the failure-manifesting process. Although we study bugs in only distributed data-processing systems, we believe that the second and third findings can be extended to other concurrent systems based on different concurrency models. Motivated by this study, we develop automated solutions to help practitioners improve the reliability of actor systems. To facilitate system testing, we propose a method to support generation of system-level tests to cover a given code location in an actor program. The test generation method consists of two phases. First, static analysis is used to construct an abstraction of an entire actor system in terms of a message flow graph… Advisors/Committee Members: Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%22%29&pagesize-30">Agha, Gul (advisor), Champaign%22%20%2Bcontributor%3A%28%22Agha%2C%20Gul%22%29&pagesize-30">Agha, Gul (Committee Chair), Champaign%22%20%2Bcontributor%3A%28%22Marinov%2C%20Darko%22%29&pagesize-30">Marinov, Darko (committee member), Champaign%22%20%2Bcontributor%3A%28%22Parthasarathy%2C%20Madhusudan%22%29&pagesize-30">Parthasarathy, Madhusudan (committee member), Champaign%22%20%2Bcontributor%3A%28%22Zhou%2C%20Yuanyuan%22%29&pagesize-30">Zhou, Yuanyuan (committee member).

Subjects/Keywords: Actor; Concurrent System; Concurrent Bug; Test Generation; Message Flow Graph; Backward Symbolic Execution; Behavioral Model; Specification Diagram; Static Analysis; Dynamic Invariant

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Li, S. (2019). Whole-system testing and analysis of actor programs. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/106237

Chicago Manual of Style (16^th Edition):

Li, Sihan. “Whole-system testing and analysis of actor programs.” 2019. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/106237.

MLA Handbook (7^th Edition):

Li, Sihan. “Whole-system testing and analysis of actor programs.” 2019. Web. 28 Feb 2021.

Vancouver:

Li S. Whole-system testing and analysis of actor programs. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2019. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/106237.

Council of Science Editors:

Li S. Whole-system testing and analysis of actor programs. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2019. Available from: http://hdl.handle.net/2142/106237

29. Cozzie, Anthony E. Detecting and Combining Programming Patterns.

Degree: PhD, 0112, 2011, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/24358

► This thesis explores detecting patterns in the most general interface to computers: source and assembly program code. Because writing computer programs correctly is so difficult,… (more)

Subjects/Keywords: data structures; programming patterns; macho

14 more images…

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Cozzie, A. E. (2011). Detecting and Combining Programming Patterns. (Doctoral Dissertation). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/24358

Chicago Manual of Style (16^th Edition):

Cozzie, Anthony E. “Detecting and Combining Programming Patterns.” 2011. Doctoral Dissertation, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/24358.

MLA Handbook (7^th Edition):

Cozzie, Anthony E. “Detecting and Combining Programming Patterns.” 2011. Web. 28 Feb 2021.

Vancouver:

Cozzie AE. Detecting and Combining Programming Patterns. [Internet] [Doctoral dissertation]. University of Illinois – Urbana-Champaign; 2011. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/24358.

Council of Science Editors:

Cozzie AE. Detecting and Combining Programming Patterns. [Doctoral Dissertation]. University of Illinois – Urbana-Champaign; 2011. Available from: http://hdl.handle.net/2142/24358

University of Illinois – Urbana-Champaign

30. Bangalore Jagannath, Vilas Shekhar. Reducing the costs of bounded-exhaustive testing.

Degree: MS, 0112, 2010, University of Illinois – Urbana-Champaign

URL: http://hdl.handle.net/2142/16865

► Bounded-exhaustive testing is an automated testing methodology that checks the code under test for all inputs within given bounds: first the user describes a set… (more)

Subjects/Keywords: bounded-exhaustive testing; test merging; test clustering; test selection; test generation; software testing

Record Details Similar Records Cite « Share

❌

APA · Chicago · MLA · Vancouver · CSE | Export to Zotero / EndNote / Reference Manager

APA (6^th Edition):

Bangalore Jagannath, V. S. (2010). Reducing the costs of bounded-exhaustive testing. (Thesis). University of Illinois – Urbana-Champaign. Retrieved from http://hdl.handle.net/2142/16865

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Chicago Manual of Style (16^th Edition):

Bangalore Jagannath, Vilas Shekhar. “Reducing the costs of bounded-exhaustive testing.” 2010. Thesis, University of Illinois – Urbana-Champaign. Accessed February 28, 2021. http://hdl.handle.net/2142/16865.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

MLA Handbook (7^th Edition):

Bangalore Jagannath, Vilas Shekhar. “Reducing the costs of bounded-exhaustive testing.” 2010. Web. 28 Feb 2021.

Vancouver:

Bangalore Jagannath VS. Reducing the costs of bounded-exhaustive testing. [Internet] [Thesis]. University of Illinois – Urbana-Champaign; 2010. [cited 2021 Feb 28]. Available from: http://hdl.handle.net/2142/16865.

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

Council of Science Editors:

Bangalore Jagannath VS. Reducing the costs of bounded-exhaustive testing. [Thesis]. University of Illinois – Urbana-Champaign; 2010. Available from: http://hdl.handle.net/2142/16865

Note: this citation may be lacking information needed for this citation format:
Not specified: Masters Thesis or Doctoral Dissertation

		in
And / Or
		in
And / Or
		in
And / Or
		in

Open Access Theses and Dissertations