Binary reduction of dependency graphs

Kalhauge, Christian Gram; Palsberg, Jens

doi:10.1145/3338906.3338956

Cited by 22 publications

(20 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Given a test oracle, delta-debugging based techniques can repeatedly split the original program into different sub-programs and re-check the test oracle to produce a debloated program [31,48,59,76]. For example, JReduce [31] partitions the original program into transitive closures based on class-level dependencies and isolates a debloated program that still passes the test. Chisel [27] uses reinforcement learning to reduce the number of search iterations during delta debugging.…”

Section: Related Workmentioning

confidence: 99%

JShrink: in-depth investigation into debloating modern Java applications

Bruce

Zhang

Arora

et al. 2020

Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Softw

View full text Add to dashboard Cite

Modern software is bloated. Demand for new functionality has led developers to include more and more features, many of which become unneeded or unused as software evolves. This phenomenon, known as software bloat, results in software consuming more resources than it otherwise needs to. How to effectively and automatically debloat software is a long-standing problem in software engineering. Various debloating techniques have been proposed since the late 1990s. However, many of these techniques are built upon pure static analysis and have yet to be extended and evaluated in the context of modern Java applications where dynamic language features are prevalent. To this end, we develop an end-to-end bytecode debloating framework called JShrink. It augments traditional static reachability analysis with dynamic profiling and type dependency analysis and renovates existing bytecode transformations to account for new language features in modern Java. We highlight several nuanced technical challenges that must be handled properly and examine behavior preservation of debloated software via regression testing. We find that (1) JShrink is able to debloat our real-world Java benchmark suite by up to 47% (14% on average); (2) accounting for dynamic language features is indeed crucial to ensure behavior preservationÐreducing 98% of test failures incurred by a purely static equivalent, Jax, and 84% for ProGuard; and (3) compared with purely dynamic approaches, integrating static analysis with dynamic profiling makes the debloated software more robust to unseen test executionsÐin 22 out of 26 projects, the debloated software ran successfully under new tests.

show abstract

Section: Related Workmentioning

confidence: 99%

JShrink: in-depth investigation into debloating modern Java applications

Bruce

Zhang

Arora

et al. 2020

Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Softw

View full text Add to dashboard Cite

show abstract

“…Their widely used tool C-Reduce [22] reduces large C programs to programs that are two orders of magnitude smaller and fit for inclusion in bug reports. In the context of finding bugs in tools that process Java bytecode, Kalhauge and Palsberg [13] noted that Java bytecode has many internal dependencies. For example, if a Java method constructs an object from a class, then it depends on that class: without the class, the method no longer type-checks.…”

Section: Introductionmentioning

confidence: 99%

“…For example, if a Java method constructs an object from a class, then it depends on that class: without the class, the method no longer type-checks. Their tool J-Reduce [13] reduces large Java bytecode programs to programs that are four times smaller but often still too large for the reader of a bug report.…”

Section: Introductionmentioning

confidence: 99%

“…Sun et al [25] took this a step further and used a syntax tree as the model in their tool Perses, which enabled the tool to avoid all syntactically invalid sub-inputs. Beyond models of syntax, Kalhauge and Palsberg [13] used a dependency graph to model semantic dependencies.…”

Section: Introductionmentioning

confidence: 99%

“…The reason is that dependency edges cannot express, for example, that if we want to preserve that A implements I and that I has a signature m, then we must also preserve that A implements m. Note that because the example is small, line-oriented reduction techniques such as ddmin may well able to reduce Figure 1a to Figure 1b. For larger examples with many internal dependencies, ddmin tends to produce disappointing results [13].…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Logical bytecode reduction

Kalhauge

Palsberg

2021

Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

Reducing a failure-inducing input to a smaller one is challenging for input with internal dependencies because most sub-inputs are invalid. Kalhauge and Palsberg made progress on this problem by mapping the task to a reduction problem for dependency graphs that avoids invalid inputs entirely. Their tool J-Reduce efficiently reduces Java bytecode to 24% of its original size, which made it the most effective tool until now. However, the output from their tool is often too large to be helpful in a bug report. In this paper, we show that more fine-grained modeling of dependencies leads to much more reduction. Specifically, we use propositional logic for specifying dependencies and we show how this works for Java bytecode. Once we have a propositional formula that specifies all valid sub-inputs, we run an algorithm that finds a small, valid, failure-inducing input. Our algorithm interleaves runs of the buggy program and calls to a procedure that finds a minimal satisfying assignment. Our experiments show that we can reduce Java bytecode to 4.6% of its original size, which is 5.3 times better than the 24.3% achieved by J-Reduce. The much smaller output is more suitable for bug reports.CCS Concepts: • Software and its engineering → Software testing and debugging; • Theory of computation → Logic.

show abstract

Evaluation of the fixed‐point iteration of minimizing delta debugging

Vince,

Kiss

2024

J Software Evolu Process

View full text Add to dashboard Cite

The minimizing Delta Debugging (DDMIN) was among the first algorithms designed to automate the task of reducing test cases. Its popularity is based on the characteristics that it works on any kind of input, without knowledge about the input structure. Several studies proved that smaller outputs can be produced faster with more advanced techniques (e.g., building a tree representation of the input and reducing that data structure); however, if the structure is unknown or changing frequently, maintaining the descriptors might not be resource‐efficient. Therefore, in this paper, we focus on the evaluation of the novel fixed‐point iteration of minimizing Delta Debugging (DDMIN*) on publicly available test suites related to software engineering. Our experiments show that DDMIN* can help reduce inputs further by 48.08% on average compared to DDMIN (using lines as the units of the reduction). Although the effectiveness of the algorithm improved, it comes with the cost of additional testing steps. This study shows how the characteristics of the input affect the results and when it pays off using DDMIN*.

show abstract

Binary reduction of dependency graphs

Cited by 22 publications

References 21 publications

JShrink: in-depth investigation into debloating modern Java applications

JShrink: in-depth investigation into debloating modern Java applications

Logical bytecode reduction

Evaluation of the fixed‐point iteration of minimizing delta debugging

Contact Info

Product

Resources

About