The Experts below are selected from a list of 2844 Experts worldwide ranked by ideXlab platform
Yan Lei - One of the best experts on this subject based on the ideXlab platform.
-
making automatic repair for large scale programs more efficient using weak Recompilation
International Conference on Software Maintenance, 2012Co-Authors: Xiaoguang Mao, Yan LeiAbstract:For large-scale programs, automatically repairing a bug by modifying source code is often a time-consuming process due to plenty of time spent on recompiling and reinstalling the patched program. To suppress the above time cost and make the repair process more efficient, a Recompilation technique called weak Recompilation is described in this paper. In weak Recompilation, a program is assumed to be constructed from a set of components, and for each candidate patch only the changed code fragment in term of one component is recompiled to a shared library; the behaviors of patched program are observed by executing the original program with an instrumentation tool which can wrap specified function. The advantage of weak Recompilation is that redundant Recompilation cost can be suppressed, and reinstallation cost will be cut down completely. We also built WAutoRepair, a system which enables scalability to fix bugs in large-scale C programs with high efficiency. The experiments confirm that our repair system significantly outperforms Genprog, a famous approach for automatic program repair. For the wireshark program containing over 2 millions lines of code, WAutoRepair spent only 0.222 seconds in recompiling one candidate patch and 8.035 seconds in totally repairing the bug, compared to Genprog separately taking about 20.484 and 75.493 seconds, on average.
-
ICSM - Making automatic repair for large-scale programs more efficient using weak Recompilation
2012 28th IEEE International Conference on Software Maintenance (ICSM), 2012Co-Authors: Xiaoguang Mao, Yan LeiAbstract:For large-scale programs, automatically repairing a bug by modifying source code is often a time-consuming process due to plenty of time spent on recompiling and reinstalling the patched program. To suppress the above time cost and make the repair process more efficient, a Recompilation technique called weak Recompilation is described in this paper. In weak Recompilation, a program is assumed to be constructed from a set of components, and for each candidate patch only the changed code fragment in term of one component is recompiled to a shared library; the behaviors of patched program are observed by executing the original program with an instrumentation tool which can wrap specified function. The advantage of weak Recompilation is that redundant Recompilation cost can be suppressed, and reinstallation cost will be cut down completely. We also built WAutoRepair, a system which enables scalability to fix bugs in large-scale C programs with high efficiency. The experiments confirm that our repair system significantly outperforms Genprog, a famous approach for automatic program repair. For the wireshark program containing over 2 millions lines of code, WAutoRepair spent only 0.222 seconds in recompiling one candidate patch and 8.035 seconds in totally repairing the bug, compared to Genprog separately taking about 20.484 and 75.493 seconds, on average.
Xiaoguang Mao - One of the best experts on this subject based on the ideXlab platform.
-
More efficient automatic repair of large-scale programs using weak Recompilation
Science China Information Sciences, 2012Co-Authors: Xiaoguang Mao, Yanjun Wen, Ziying DaiAbstract:Automatically repairing a bug can be a time-consuming process especially for large-scale programs owing to the significant amount of time spent recompiling and reinstalling the patched program. To reduce this time overhead and speed up the repair process, in this paper we present a Recompilation technique called weak Recompilation. In weak Recompilation, we assume that a program consists of a set of components, and for each candidate patch only the altered components are recompiled to a shared library. The original program is then dynamically updated by a function indirection mechanism. The advantage of weak Recompilation is that redundant Recompilation cost can be avoided, and while the reinstallation cost is completely eliminated as the original executable program is not modified at all. For maximum applicability of weak Recompilation we created WAutoRepair, a scalable system for fixing bugs with high efficiency in large-scale C programs. The experiments on real bugs in widely used programs show that our repair system significantly outperforms Genprog, a well-known approach to automatic program repair. For the wireshark program containing over 2 million lines of code, WAutoRepair is over 128 times faster in terms of Recompilation cost than Genprog.
-
making automatic repair for large scale programs more efficient using weak Recompilation
International Conference on Software Maintenance, 2012Co-Authors: Xiaoguang Mao, Yan LeiAbstract:For large-scale programs, automatically repairing a bug by modifying source code is often a time-consuming process due to plenty of time spent on recompiling and reinstalling the patched program. To suppress the above time cost and make the repair process more efficient, a Recompilation technique called weak Recompilation is described in this paper. In weak Recompilation, a program is assumed to be constructed from a set of components, and for each candidate patch only the changed code fragment in term of one component is recompiled to a shared library; the behaviors of patched program are observed by executing the original program with an instrumentation tool which can wrap specified function. The advantage of weak Recompilation is that redundant Recompilation cost can be suppressed, and reinstallation cost will be cut down completely. We also built WAutoRepair, a system which enables scalability to fix bugs in large-scale C programs with high efficiency. The experiments confirm that our repair system significantly outperforms Genprog, a famous approach for automatic program repair. For the wireshark program containing over 2 millions lines of code, WAutoRepair spent only 0.222 seconds in recompiling one candidate patch and 8.035 seconds in totally repairing the bug, compared to Genprog separately taking about 20.484 and 75.493 seconds, on average.
-
ICSM - Making automatic repair for large-scale programs more efficient using weak Recompilation
2012 28th IEEE International Conference on Software Maintenance (ICSM), 2012Co-Authors: Xiaoguang Mao, Yan LeiAbstract:For large-scale programs, automatically repairing a bug by modifying source code is often a time-consuming process due to plenty of time spent on recompiling and reinstalling the patched program. To suppress the above time cost and make the repair process more efficient, a Recompilation technique called weak Recompilation is described in this paper. In weak Recompilation, a program is assumed to be constructed from a set of components, and for each candidate patch only the changed code fragment in term of one component is recompiled to a shared library; the behaviors of patched program are observed by executing the original program with an instrumentation tool which can wrap specified function. The advantage of weak Recompilation is that redundant Recompilation cost can be suppressed, and reinstallation cost will be cut down completely. We also built WAutoRepair, a system which enables scalability to fix bugs in large-scale C programs with high efficiency. The experiments confirm that our repair system significantly outperforms Genprog, a famous approach for automatic program repair. For the wireshark program containing over 2 millions lines of code, WAutoRepair spent only 0.222 seconds in recompiling one candidate patch and 8.035 seconds in totally repairing the bug, compared to Genprog separately taking about 20.484 and 75.493 seconds, on average.
David Macqueen - One of the best experts on this subject based on the ideXlab platform.
-
PLDI - Separate compilation for Standard ML
Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation - PLDI '94, 1994Co-Authors: Andrew W. Appel, David MacqueenAbstract:Languages that support abstraction and modular structure, such as Standard ML, Modula, Ada, and (more or less) C++, may have deeply nested dependency hierarchies among source files. In ML the problem is particularly severe because ML's powerful parameterized module (functor) facility entails dependencies among implementation modules, not just among interfaces. To efficiently compile individual modules in such languages, it is useful (in ML, necessary) to infer, digest, and cache the static environment resulting from the compilation of each module. Our system provides a simple model of compilation and linkage that supports incremental Recompilation (a restricted form of separate compilation) with type-safe linkage. This model is made available to user programs in the form of a set of internal compiler modules, a feature that we call the “visible compiler”. The chief client of this interface is the IRM incremental Recompilation manager from CMU.
Giovanni Lagorio - One of the best experts on this subject based on the ideXlab platform.
-
Capturing ghost dependencies in Java sources
The Journal of Object Technology, 2004Co-Authors: Giovanni LagorioAbstract:All non trivial applications consist of many sources, which usually depend on each other. For this reason, a change to some sources may affect the compilation of other (unchanged) sources. Hence, the Recompilation must be propagated to the unchanged sources that depend on the changed ones, in order to obtain the same result a global Recompilation would produce. Most IDEs (Integrated Development Environments) provide smart dependency checking; that is, they automate the task of finding these dependencies and propagating the Recompilation when an application is rebuilt. In this paper we study the problem of extracting dependency information from Java sources and propose an encoding of these dependency information as regular expressions. This encoding is both compact to store and fast to check. Furthermore, our technique detects a particular kind of dependencies, which we call ghost dependencies, that popular tools, even commercial ones, fail to detect. Because of this failure, some required Recompilations are not triggered by these tools and the result of their incremental Recompilations is not equivalent to the Recompilation of all sources.
-
Stronger Typings for Separate Compilation of Java-like Languages.
The Journal of Object Technology, 2004Co-Authors: Davide Ancona, Giovanni LagorioAbstract:We define an algorithm for smarter Recompilation of a small but significant Java-like language; such an algorithm is inspired by a type system previously defined by Ancona and Zucca. In comparison with all previous type systems for Java-like languages, this system enjoys the principal typings property, and is based on the two novel notions of local type assumption and entailment of type environments. The former allows the user to specify minimal requirements on the source fragments which need to be compiled in isolation, whereas the latter syntactically captures the concept of stronger type assumption. One of the most important practical advantages of this system is a better support for selective Recompilation; indeed, it is possible to define an algorithm directly driven by the typing rules which is able to avoid the unnecessary Recompilation steps which are usually performed by the Java compilers. The algorithm is smarter in the sense that it never forces useless Recompilations, that is, Recompilations which would generate the same binary fragment obtained from the previous compilation of the same source fragment. Finally, we show that the algorithm can actually speed up the overall Recompilation process, since checking for Recompilation is always strictly less expensive than recompiling the same fragment.
-
Towards a Smart Compilation Manager for Java (Extended Abstract)
2003Co-Authors: Giovanni LagorioAbstract:It is often infeasible to recompile all the sources an applica- tion consists of each time a change is made. Yet, a Recompilation strategy which does not guarantee the same outcome of an entire Recompilation is not useful: why wasting time in debugging a program (a set of .class files in the Java case) which might behave differently from the program obtained recompiling all the sources from scratch? We say that a compilation strategy is sound if it recompiles, besides the changed sources, all the unchanged sources whose new binary, pro- duced by the overall Recompilation, would differ from the existing one (if any) and all the sources for which the Recompilation would be unde- fined: indeed, when the entire compilation fails, so should do the partial Recompilation. We say that a compilation strategy is minimal if it never recompiles an unchanged source whose new binary would be equal to the existing one. In this paper we present a compilation strategy for a substantial subset of Java which is proved to be sound and minimal.
-
ICTCS - Towards a Smart Compilation Manager for Java
Lecture Notes in Computer Science, 2003Co-Authors: Giovanni LagorioAbstract:It is often infeasible to recompile all the sources an application consists of each time a change is made. Yet, a Recompilation strategy which does not guarantee the same outcome of an entire Recompilation is not useful: why wasting time in debugging a program (a set of .class files in the Java case) which might behave differently from the program obtained recompiling all the sources from scratch?
Andrew W. Appel - One of the best experts on this subject based on the ideXlab platform.
-
PLDI - Separate compilation for Standard ML
Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation - PLDI '94, 1994Co-Authors: Andrew W. Appel, David MacqueenAbstract:Languages that support abstraction and modular structure, such as Standard ML, Modula, Ada, and (more or less) C++, may have deeply nested dependency hierarchies among source files. In ML the problem is particularly severe because ML's powerful parameterized module (functor) facility entails dependencies among implementation modules, not just among interfaces. To efficiently compile individual modules in such languages, it is useful (in ML, necessary) to infer, digest, and cache the static environment resulting from the compilation of each module. Our system provides a simple model of compilation and linkage that supports incremental Recompilation (a restricted form of separate compilation) with type-safe linkage. This model is made available to user programs in the form of a set of internal compiler modules, a feature that we call the “visible compiler”. The chief client of this interface is the IRM incremental Recompilation manager from CMU.