Inlining Research Articles

Taxonomy of inline code comment smells

Code comments play a vital role in source code comprehension and software maintainability. It is common for developers to write comments to explain a code snippet, and commenting code is generally considered a good practice in software engineering. However, low-quality comments can have a detrimental effect on software quality or be ineffective for code understanding. This study aims to create a taxonomy of inline code comment smells and determine how frequently each smell type occurs in software projects. We conducted a multivocal literature review to define the initial taxonomy of inline comment smells. Afterward, we manually labeled 2447 inline comments from eight open-source projects where half of them were Java, and another half were Python projects. We created a taxonomy of 11 inline code comment smell types and found out that the smells exist in both Java and Python projects with varying degrees. Moreover, we conducted an online survey with 41 software practitioners to learn their opinions on these smells and their impact on code comprehension and software maintainability. The survey respondents generally agreed with the taxonomy; however, they reported that some smell types might have a positive effect on code comprehension in certain scenarios. We also opened pull requests and issues fixing the comment smells in the sampled projects, where we got a 27% acceptance rate. We share our manually labeled dataset online and provide implications for software engineering practitioners, researchers, and educators.

Multi-Intent Inline Code Comment Generation via Large Language Model

Code comment generation typically refers to the process of generating concise natural language descriptions for a piece of code, which facilitates program comprehension activities. Inline code comments, as a part of code comments, are also crucial for program comprehension. Recently, the emergence of large language models (LLMs) has significantly boosted the performance of natural language processing tasks. This naturally inspires us to explore the performance of the LLMs in the task of inline code comment generation. To this end, we evaluate open-source LLMs on a large-scale dataset and compare the results with the current state-of-the-art methods. Specifically, we explore the model performance in the following scenarios based on the widely used evaluation metrics (i.e. BLEU, Meteor, and ROUGE-L): (1) generation with simple instruction; (2) few-shot-guided generation with random examples selected from the database; (3) few-shot-guided generation with similar examples selected from the database; and (4) adopt the re-ranking strategy for the output of LLMs. Our findings reveal that: (1) under the simple instruction scenario, LLMs could not fully show the potential in the task of inline comment generation compared to the state-of-the-art models; (2) random few-shot leads to a slight improvement; (3) similar few-shot and re-ranking strategy could significantly enhance the performance of LLMs; and (4) for inline comment and code snippet pairs with different intents, why category achieves the best performance and what category achieves relatively poorer performance. That remains consistent across all four scenarios. Our findings shed light on future research directions for using LLMs in inline comment generation tasks.

Call-site tree and its application in function inlining

Call-site tree and its application in function inlining

Call-site tree and its application in function inlining

Call-site tree and its application in function inlining

Techniques and Trade-Offs in Function Inlining Optimization

Function inlining is a critical optimization technique used by compilers to improve program performance by replacing a function call with the body of the function and eliminating the overhead associated with function calls. However, the decision of when to inline functions and when not to is a nontrivial problem due to interactions with the rest of the compiler pipeline. Incorrect inlining decisions can cause runtime performance degradation, making this problem a crucial one to study. This paper reviews the different techniques used to optimize function inlining, including simple textual substitution, profile-guided inlining, interprocedural optimization, partial inlining, speculative inlining, and advanced techniques such as indirect call optimizations. Each technique has its strengths, weaknesses, and trade-offs, and ongoing research is exploring ways to overcome these challenges. Optimizing function inlining is a complex problem, and different techniques offer different tradeoffs. Further research to improve the performance of function inlining while minimizing any potential drawbacks could be pursued based on this paper.

Towards Efficient Dynamic Binary Translation Optimizations Based on RISC Architectural Features

Dynamic binary translation (DBT) is a core technology that enables the migration of legacy software to different instruction set architectures while maintaining the original semantics. However, the development and maintenance of an efficient cross-DBT system are challenging. Key challenges include memory access overhead, inefficient instruction simulation, and frequent context switches. In this paper, we propose three novel optimization techniques. First, we formalize a register mapping cost model and investigate a hierarchical register mapping approach to bridge the memory access overhead. Second, we accelerate floating point (FP) emulation by surrounding the use of hardware FP unit with high-efficiency non-FP code. Third, we present a function inlining approach to alleviating the overhead associated with indirect control lookup. On the system side, we implement our approach on ARM64 and SW64 architectures based on QEMU and extensively evaluate the effectiveness with the SPEC2006 benchmark suite. The experimental results show that an average of 1.28× performance speedup and 13.41% code size reduction can be achieved on SW64. Similarly, on ARM64, we achieve an average of 1.15× performance speedup and 11.48% code size reduction.

ICG: A Machine Learning Benchmark Dataset and Baselines for Inline Code Comments Generation Task

As a fundamental component of software documentation, code comments could help developers comprehend and maintain programs. Several datasets of method header comments have been proposed in previous studies for machine learning-based code comment generation. As part of code comments, inline code comments are also crucial for code understanding activities. However, unlike method header comments written in a standard format and describing the whole method code, inline comments are often written in arbitrary formats by developers due to timelines pressures and different aspects of code snippets in the method are described. Currently, there is no large-scale dataset used for inline comments generation considering these. Hence, this naturally inspires us to explore whether we can construct a dataset to foster machine learning research that not only performs fine-grained noise-cleaning but conducts a taxonomy of inline comments. To this end, we first collect inline comments and code snippets from 8000 Java projects on GitHub. Then, we conduct a manual review to obtain heuristic rules, which could be used to clean the data noise in a fine-grained manner. As a result, we construct a large-scale benchmark dataset named ICG with 5,740,770 pairs of inline comments and code snippets. We then build a comprehensive taxonomy and conduct a statistical and manual analysis to explore the performances of different categories of inline comments, such as helpfulness in code understanding. After that, we provide and compare several baseline models to automatically generate inline comments, such as CodeBERT, to enhance the usability of the benchmark for researchers. The availability of our benchmark and baselines can help develop and validate new inline comment generation methods, which would also further facilitate code understanding activities.

1-to-1 or 1-to-n? Investigating the Effect of Function Inlining on Binary Similarity Analysis

Binary similarity analysis is critical to many code-reuse-related issues, where function matching is its fundamental task. “ 1-to-1 ” mechanism has been applied in most binary similarity analysis works, in which one function in a binary file is matched against one function in a source file or binary file. However, we discover that the function mapping is a more complex problem of “ 1-to-n ” (one binary function matches multiple source functions or binary functions) or even “ n-to-n ” (multiple binary functions match multiple binary functions) due to the existence of function inlining , different from traditional understanding. In this article, we investigate the effect of function inlining on binary similarity analysis. We carry out three studies to investigate the extent of function inlining, the performance of existing works under function inlining, and the effectiveness of existing inlining-simulation strategies. Firstly, a scalable and lightweight identification method is designed to recover function inlining in binaries. 88 projects (compiled in 288 versions and resulting in 32,460,156 binary functions) are collected and analyzed to construct four inlining-oriented datasets for four security tasks in the software supply chain, including code search, OSS (Open Source Software) reuse detection, vulnerability detection, and patch presence test. Datasets reveal that the proportion of function inlining ranges from 30–40% when using O3 and sometimes can reach nearly 70%. Then, we evaluate four existing works on our dataset. Results show most existing works neglect inlining and use the “1-to-1” mechanism. The mismatches cause a 30% loss in performance during code search and a 40% loss during vulnerability detection. Moreover, most inlined functions would be ignored during OSS reuse detection and patch presence test, thus leaving these functions risky. Finally, we analyze two inlining-simulation strategies on our dataset. It is shown that they miss nearly 40% of the inlined functions, and there is still a large space for promotion. By precisely recovering when function inlining happens, we discover that inlining is usually cumulative when optimization increases. Thus, conditional inlining and incremental inlining are recommended to design a low-cost and high-coverage inlining-simulation strategy.

Flow Chart Generation-Based Source Code Similarity Detection Using Process Mining

Source code similarity detection has extensive applications in computer programming teaching and software intellectual property protection. In the teaching of computer programming courses, students may utilize some complex source code obfuscation techniques, e.g., opaque predicates, loop unrolling, and function inlining and outlining, to reduce the similarity between code fragments and avoid the plagiarism detection. Existing source code similarity detection approaches only consider static features of source code, making it difficult to cope with more complex code obfuscation techniques. In this paper, we propose a novel source code similarity detection approach by considering the dynamic features at runtime of source code using process mining. More specifically, given two pieces of source code, their running logs are obtained by source code instrumentation and execution. Next, process mining is used to obtain the flow charts of the two pieces of source code by analyzing their collected running logs. Finally, similarity of the two pieces of source code is measured by computing the similarity of these two flow charts. Experimental results show that the proposed approach can deal with more complex obfuscation techniques including opaque predicates and loop unrolling as well as function inlining and outlining, which cannot be handled by existing work properly. Therefore, we argue that our approach can defeat commonly used code obfuscation techniques more effectively for source code similarity detection than the existing state-of-the-art approaches.

Synthesis of Modified Nucleoside Oligophosphates Simplified: Fast, Pure, and Protecting Group Free.

Phosphoramidite analogues of modified cyclotriphosphates provide a general and step-economical synthesis of nucleoside triphosphates and analogues on scale without the need for protecting groups. These reagents enable rapid access to pure nucleoside oligophosphates and a range of other analogues that were previously difficult to obtain (e.g., NH, CH2, CCl2, and CF2 replacements for O, phosphono- and phosphoimidazolides, -morpholidates, -azidates, and -fluoridates). DFT calculations demonstrate that the selectivity of the cyclotriphosphate opening reactions proceeds via an in-line substitution mechanism that displaces the least charged leaving group.

In-line inspection solution for codes on complex backgrounds for the plastic container industry

Machine vision technologies have been widely used for automating the product quality control, but the defect inspection for codes on complex backgrounds is still a challenging task in the plastic container industry. In this work, an efficient and accurate inspection solution based on deep learning was proposed aiming at the detection of codes on complex backgrounds for the plastic container such as beverage packages. Firstly, image processing algorithms such as the region translation method, morphological processing, and image matching technology based on SIFT (Scale Invariant Feature Transform) features were implemented to generate synthetic defective samples, which moderated the class-imbalance problem. Data augmentation strategies were used to increase the amount of training data. Secondly, the ShuffleNet V2 framework was adapted to inspect inkjet codes on complex backgrounds. Additionally, the transfer learning was used to transfer the trained model to other inspection tasks for different kinds of packages. Finally, the proposed approach was built onto an in-line code inspection apparatus for the plastic container industry, and an accuracy of 0.9988 was achieved. The in-line testing results of false detection and omission detection rates demonstrated that the proposed solution can fully meet the production requirements. To the best of our knowledge, this report describes the first time that deep learning has been applied to the industrial defect inspection for the plastic container industry.

Hyphenation of Supercritical Fluid Chromatography and NMR with In-Line Sample Concentration.

By coupling supercritical fluid chromatography (SFC) and nuclear magnetic resonance (NMR) in-line, a powerful analytical method arises that enables chemically specific analysis of a broad range of complex mixtures. However, during chromatography, the compounds are diluted in the mobile phase, in this case supercritical CO2 (scCO2), often resulting in concentrations that are too low to be detected by NMR spectroscopy or at least requiring excessive signal averaging. We present a hyphenated SFC-NMR setup with an integrated approach for concentrating samples in-line, which are diluted in scCO2 during chromatography. This in-line concentration is achieved by controlled in-line expansion of the scCO2. As a proof of concept four isomers of vitamin E (tocopherol) were isolated by SFC, concentrated in-line by expanding CO2 from 120 to 50 bar, and finally shuttled to the NMR spectrometer fitted with a dedicated probehead for spectroscopic characterization of microfluidic samples. The abundant isomers were readily detected, supporting the viability of SFC-NMR as a powerful analytical tool.

Correctness of speculative optimizations with dynamic deoptimization

High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.

Implementing a performant scheme interpreter for the web in asm.js

This paper presents the implementation of an efficient interpreter for a Scheme-like language using manually written asm.js code. The asm.js specification defines an optimizable subset of JavaScript that has already served well as a compilation target for web applications where performance is critical. However, its usage as a human-writable language that can be integrated into existing projects to improve performance has remained largely unexplored. We therefore apply this strategy to optimize the implementation of an interpreter. We also discuss the feasibility of this approach, as writing asm.js by hand is generally not its recommended use-case. We therefore present a macro system to solve the challenges we encounter. The resulting interpreter is compared to the original C implementation and its compiled equivalent in asm.js. This way, we evaluate whether manual integration with asm.js provides the necessary performance to bring larger applications and runtimes to the web. We also refactor our implementation to assess how more JavaScript code can cohabit with asm.js code, improving maintainability of the implementation while preserving near-native performance. In the case of our interpreter, this improved maintainability enables adding more complex optimizations. We investigate the addition of function inlining, for which we validate the performance gain.

Specialization of Generic Array Accesses After Inlining

We have implemented an optimization that specializes type-generic array accesses after inlining of polymorphic functions in the native-code OCaml compiler. Polymorphic array operations (read and write) in OCaml require runtime type dispatch because of ad hoc memory representations of integer and float arrays. It cannot be removed even after being monomorphized by inlining because the intermediate language is mostly untyped. We therefore extended it with explicit type application like System F (while keeping implicit type abstraction by means of unique identifiers for type variables). Our optimization has achieved up to 21% speed-up of numerical programs.

Parsons Brinckerhoff: The Second Avenue Subway (a)

Can a company base a major proposal on its good reputation, history with the client, and a perspective that differs from the client's own? Emphasizing both its engineering capability and 80 years' experience, Parsons Brinckerhoff spends one year and $1 million preparing a proposal to build a $17 billion subway line. Competition from four equally qualified firms is stiff, but PB is sure its history and top-level MTA connections make it a shoe-in. Despite MTA's concerns about the finished line's functionality, PB believes the construction of the tunnel itself is the key to winning the bid. In the A case, the firm awaits the good news. The B and C cases reveal the results and the direction the company then chooses to take. (A teaching note is available to registered faculty members.) Excerpt UVA-M-0793 Rev. Aug. 11, 2011 Parsons Brinckerhoff: The Second Avenue Subway (A) William Barclay Parsons Jr. may have displayed a “humorless rectitude” in his dealings with people, but he sure knew how to build things. Parsons founded a consulting engineering firm in New York City in 1885 that would go on to design some of the largest, most complex, and most intriguing building projects in the world. Parsons himself was a New Yorker, born in 1859, just as the occupation of engineer was reaching its modern definition—a person trained to design and construct roads, bridges, and other structures. Parsons was gifted, if not a genius. By the age of 25 and fresh out of Columbia School of Mines (the precursor to the School of Engineering), he won a job that placed him in charge of repairs at the huge Erie Railroad Co. But Parsons expected bigger things for himself, and on January 1, 1885, he quit his salaried job and hung out his engineering shingle in New York City. His brains and pluck quickly led to a string of engineering projects, including the building of the Fort Worth and Rio Grande Railroad and a bridge over the Brazos River in Texas, the first railroad in Jamaica, major water supply systems for the cities of Vicksburg and Natchez in Mississippi, and several hydroelectric plants, including one on the Hudson River. . . .

Cryogenic expansion joint for LNG service

Pipelines transporting cryogenic liquids, such as liquefied natural gas (LNG), are typically constructed with metal components with a relatively high thermal expansion coefficient. Pipelines contract in length due to the large temperature differential that occurs. To accommodate this thermal contraction, LNG plants, offloading jetties, and other facilities typically utilise expansion loops and/or conventional in-line expansion joints (e.g. bellows). However, expansion loops require a large amount of space and support platforms, which can be costly and/or disruptive to an LNG facility construction. Additionally, conventional bellows-type expansion joints offer very little torsional strength, which may lead to catastrophic failure in the joint. Engineers at Clough Limited have patented two unique embodiments of a cryogenic expansion joint: a sliding concentric pipe-in-pipe cryogenic expansion joint; and a torsional cryogenic expansion joint. Both designs utilise inherent material properties to seal sequential pipeline segments together at cryogenic conditions. The pipe-in-pipe expansion joint provides large axial and unlimited torsional movement. The torsional expansion joint provides unlimited radial and some axial movement. These embodiments eliminate the large conventional expansion loops and reduce project capital expenditure.

Random model sampling: Making craig interpolation work when it should not

One of the most serious problems when doing program analyses is dealing with function calls. While function inlining is the traditional approach to this problem, it nonetheless suffers from the increase in analysis complexity due to the state space explosion. Craig interpolation has been successfully used in recent years in the context of bounded model checking to do function summarization which allows one to replace the complete function body with its succinct summary and, therefore, reduce the complexity, but unfortunately this technique can be applied only to a pair of unsatisfiable formulae. In this work-in-progress paper we present an approach to function summarization based on Craig interpolation that overcomes its limitation by using random model sampling. It captures interesting input/output relations, strengthening satisfiable formulae into unsatisfiable ones and thus allowing the use of Craig interpolation. Evaluation results show the applicability of this approach; in our future work we plan to do a more extensive evaluation on real-world examples.

Accurate profiling in the presence of dynamic compilation

Many profilers based on bytecode instrumentation yield wrong results in the presence of an optimizing dynamic compiler, either due to not being aware of optimizations such as stack allocation and method inlining, or due to the inserted code disrupting such optimizations. To avoid such perturbations, we present a novel technique to make any profiler implemented at the bytecode level aware of optimizations performed by the dynamic compiler. We implement our approach in a state-of-the-art Java virtual machine and demonstrate its significance with concrete profilers. We quantify the impact of escape analysis on allocation profiling, object life-time analysis, and the impact of method inlining on callsite profiling. We illustrate how our approach enables new kinds of profilers, such as a profiler for non-inlined callsites, and a testing framework for locating performance bugs in dynamic compiler implementations.

Java-to-JavaScript translation via structured control flow reconstruction of compiler IR

We present an approach to cross-compile Java bytecodes to Java-Script, building on existing Java optimizing compiler technology. Static analysis determines which Java classes and methods are reachable. These are then translated to JavaScript using a re-configured Java just-in-time compiler with a new back end that generates JavaScript instead of machine code. Standard compiler optimizations such as method inlining and global value numbering, as well as advanced optimizations such as escape analysis, lead to compact and optimized JavaScript code. Compiler IR is unstructured, so structured control flow needs to be reconstructed before code generation is possible. We present details of our control flow reconstruction algorithm. Our system is based on Graal, an open-source optimizing compiler for the Java HotSpot VM and other VMs. The modular and VM-independent architecture of Graal allows us to reuse the intermediate representation, the bytecode parser, and the high-level optimizations. Our custom back end first performs control flow reconstruction and then JavaScript code generation. The generated JavaScript undergoes a set of optimizations to increase readability and performance. Static analysis is performed on the Graal intermediate representation as well. Benchmark results for medium-sized Java benchmarks such as SPECjbb2005 run with acceptable performance on the V8 JavaScript VM.