COOPER,K.AND MCINTOSH,N. 1999. Enhanced code compression for embedded RISC processors. In Proceedings of the ACM SIGPLAN '99 Conference on Programming Language Design and Implementation. 139--149.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....set appropriately at the two call sites. 1. 3 Comparison to previous work A few approaches to clone group extraction in source code have been proposed in the literature [10, 2] while much work has been reported in the area of compacting assembly code by identifying and extracting clones (e.g. [18, 7, 8]) The novel aspect of our work in comparison to all previous clone group extraction approaches is the use of semanticspreserving transformations both to move intervening noncloned statements out of the way, and to reorder out of order clones. Also, ours is the first approach to handle exiting ....

....clones. Also, ours is the first approach to handle exiting jumps in to be extracted code. These features allow our algorithm to perform well on di#cult clone groups, where the performance of previous approaches is unsatisfactory. In addition to disallowing exiting jumps, the approaches of [18, 7] only find sequences that are contiguous and that match exactly. The approach of [8] does allow inexactly matching sequences; however they perform no code motion, using guarding to resolve all mismatches when extracting non contiguous clones or out of order clones. This means that every ....

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. ACM Conf. on Programming Language Design and Implementation, pages 139--149, May 1999.

....CCR 0220334, and EIA 0080123 to the Univ. of Arizona. Code compaction techniques. A commonly used approach to code compaction is the application of compiler based transformations which nd recurring code sequences in an application and replace them by a single shared copy of the code sequence [16, 7, 17, 1, 2]. There are two commonly used transformations for removing repeated occurrences of a code sequence: tail merging [16, 7, 1] and procedural abstraction [17, 2] If the recurring sequences appear along alternate paths immediately prior to a merge point in the control ow graph, tail merging is ....

.... is the application of compiler based transformations which nd recurring code sequences in an application and replace them by a single shared copy of the code sequence [16, 7, 17, 1, 2] There are two commonly used transformations for removing repeated occurrences of a code sequence: tail merging [16, 7, 1] and procedural abstraction [17, 2] If the recurring sequences appear along alternate paths immediately prior to a merge point in the control ow graph, tail merging is applied to replace multiple occurrences of the code sequence immediately before the merge point by a single occurrence of the ....

K. Cooper and N. McIntosh, \Enhanced Code Compression for Embedded RISC Processors," SIGPLAN Conference on Programming Language Design and Implementation (PLDI), May 1999.

....future lifetime of an object is proportional to its current age. Reducing space requirements We have compared the STP approach with the big bag of pages (BiBoP) technique in Section 4.2. The STP approach is different from the techniques aimed at producing compact code for embedded processors [30, 15], in that it reduces memory consumed by data rather than code. It is also different from the hardware based techniques for compressing the contents of main memory [44] A technique for delayed allocation of infrequently accessed or cold objects, a construction on demand, which aims to reduce ....

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. of PLDI 1999.

....bytecode, the average overall compression factor is 60 . 1 Introduction 1.1 Motivation Embedded systems are resource constrained devices requiring careful attention to memory usage and power consumption. To serve these goals, several researchers are taking the approach of reducing program size [6, 26, 2, 13, 11, 12]. Recently, IBM has developed CodePack [11, 12] to compress programs for the PowerPC processor for the embedded market. Others have developed dual processors that switch between compressed and uncompressed modes of decoding [13, 2] To tackle such systems in Java, Sun has taken the approach of ....

....Proebsting s [22] work. Their technique is competitive with gzip on native code. But it is not reported if the compression obtained is due to the use of the VM or the compression of the virtual program. Moreover, no timing of the execution of compressed programs is reported. Cooper and McIntosh [6] reduce program size by replacing particular repetitive sequences of instructions with a branch. The code saving is on average 5 . Cooper et al. 7] searches, using a genetic algorithm technique, a combination of compilation techniques to reduce code size. These works di er from ours since they ....

Keith D. Cooper and Nathaniel McIntosh. Enhanced code compression for embedded RISC processors. In Proc. Conf. on Programming Languages Design and Implementation, 1999.

....of a wide range of program representations: source programs, intermediate representations, machine codes, etc. 24] The resulting compressed form either must be decompressed (and perhaps compiled) before execution [9, 10, 11] or it can be executed (or interpreted [13, 21] without decompression [6, 12]. The first method results in a smaller compressed representation than the second, but requires the time and space overhead of decompression before execution. We avoid requiring a large amount of additional space to place the decompressed code by choosing to decompress small pieces of the code on ....

....or the hardware of the computer. Most of the earlier work on code compression to yield smaller executables treated an executable program as a simple linear sequence of instructions, and used a suffix tree construction to identify repeated code fragments that could be abstracted out into functions [6, 12]. We have recently shown that it is possible to obtain results that are as good, or better, by using aggressive inter procedural size reducing compiler optimizations applied to the control flow graph of the program, instead of using a suffix tree construction over a linear sequence of instructions ....

K. D. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. SIGPLAN '99 Conf. on Programming Language Design and Implementation, pages 139--149, May 1999.

....require programs to be written in a particular fashion, cannot lose control of the system, and demonstrates that successful nonpreemptive multitasking derives from the underlying program representation, not the program behavior. Software based code decompression has been explored, for example, in [9, 11, 20]. Our approach is loosely related to Liao et al. who extract common code sequences and invoke them via function calls at run time [21] Our current contribution is not a new compression method, but a natural way to incorporate decompression into program execution. 7 Future Work There are many ....

K. D. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proceedings of the ACM SIGPLAN '99 Conference on Programming Language Design and Implementation, pages 139-149, 1999.

....of a wide range of program representations: source languages, intermediate representations, machine codes, etc. 15] The resulting compressed form either must be decompressed (and perhaps compiled) before execution [5, 6, 7] or it can be executed (or interpreted [9, 14] without decompression [4, 8]. The first method results in a smaller compressed representation than the second, but requires the overhead of decompression before execution. This overhead may be negligible and, in fact, may be compensated for by the savings in transmission or retrieval cost [7] A more severe problem is that ....

....code fragments, e.g. due to the use of different registers, that may not actually have any effect on the behavior of the code. This shortcoming has been addressed by Baker, who proposed parameterized suffix trees [1] by Cooper and McIntosh, who use register renaming to get around this problem [4] (a similar approach is discussed by Baker and Manber [2] and by Zastre, who uses parameterized procedural abstractions [16] The main idea here is to rewrite instructions so that instead of using hard coded register names, the (register) operands of an instruction are expressed, if possible, in ....

[Article contains additional citation context not shown here]

K. D. Cooper and N. McIntosh, "Enhanced Code Compression for Embedded RISC Processors". Proc. SIGPLAN '99 Conference on Programming Language Design and Implementation, May 1999 (to appear).

....under grants CCR 0073394, EIA 0080123, and ASC 9720738. mation of programs to reduce their memory footprint while keeping them directly executable. Work on code compaction has generally focused on identifying repeated instruction sequences within a program and abstracting them into functions [6, 14] or macro instructions in programmable execution environments such as the Java Virtual Machine [4] Work on data compaction is limited to simple literal address removal from object les [21] Whereas program compaction compacts code and data in a program, program extraction identi es those parts ....

....[16, 17] By contrast, programs compacted using our techniques can be executed directly without any decompression or special hardware support. Most of the previous work on code compaction to yield smaller executables treats an executable program as a simple linear sequence of instructions [3, 6, 14]. They use sux trees to identify repeated instructions in the program and abstract them out into functions. None of these works address the issue of reducing the size of the data section within a program. The size reductions they report are modest, averaging about 4 7 . Clausen et al. 4] applied ....

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. PLDI, pages 139-149, May 1999.

....program by renaming the registers of an instruction so that it matches another instruction in the program whenever possible. This increases the number of instructions in the program that are identical and allow the compressor to make use of the repetition. Cooper and McIntosh Cooper and McIntosh [Cooper99] use register renaming to increase opportunities to apply procedure abstraction and cross jumping [Wulf75] They search the entire executable binary for sequences of instructions (possibly spanning several basic blocks) that have similar data flow and control flow. They then attempt to make the ....

Keith D. Cooper and Nathaniel McIntosh, "Enhanced code compression for embedded RISC processors", Proc. Conf. on Programming Languages Design and Implementation, pp. 139-149, 1999.

....take as little space as possible. To this end, a few approaches to limiting the amount of memory needed to hold executable code have surfaced. Some techniques look at instruction scheduling [CS98, CSS99] and its effect on target code size. Other techniques employ some form of pattern matching [CM99, LDK99] to eliminate regions of repeated code. A third genre of technique attempts to physically compress the target code [LW98] to save on precious memory space. An attempt to limit target code growth via efficient instruction scheduling was introduced by [CS98] This technique merely tries to ....

....and inserts them into a dictionary. The code sequence is replaced with a mini subroutine call to the dictionary. Cooper and McIntosh s approach differ in that it finds regions of code that are similar and deletes all subsequently similar regions. Control is then funneled through the first region [CM99] This technique also employs some interesting ways to identify larger and a greater number of regions of similar code. Here register names and the names for the targets of branches are abstracted (removed and given a generic name) For example, if two pieces of code were similar except that they ....

[Article contains additional citation context not shown here]

Keith D. Cooper and Nathaniel McIntosh. Enhanced code compression for embedded risc processors. In ACM Proceedings of the SIGPLAN

....decompression costs. Faster levels typically require faster decompression or, in the limit, a compressed form that can be interpreted directly, without the time or memory costs of a separate decompression step. Though recently there has been an increase in research on program compression e.g. [1, 3, 7, 8, 11, 13, 14, 16, 17, 20, 21, 22, 24, 27], very little of it has focused on methods, sometimes called code compaction methods, that avoid any decompression before execution. These methods produce representations that can be directly executed [7, 8] or interpreted [11, 16, 17, 21, 24] and, as a result, are more limited than schemes that ....

....in research on program compression e.g. 1, 3, 7, 8, 11, 13, 14, 16, 17, 20, 21, 22, 24, 27] very little of it has focused on methods, sometimes called code compaction methods, that avoid any decompression before execution. These methods produce representations that can be directly executed [7, 8] or interpreted [11, 16, 17, 21, 24] and, as a result, are more limited than schemes that have the flexibility to decompress before execution. Certain embedded systems supply one of the clearest examples of the need for zero overhead decompression. These systems typically store much of their code ....

K. D. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. PLDI, pp.139-149 (May 1999).

....grants CCR 0073394, EIA 0080123, and ASC 9720738. while retaining the property that they can be executed directly without requiring any decompression. Work on code compaction has generally focused on identifying repeated instruction sequences within a program and abstracting them into functions [6, 12] or macro instructions in programmable execution environments such as the Java Virtual Machine [4] Work on data compaction is limited to simple literal address removal from object les [19] Whereas program compaction compacts code and data in a program, program extraction identi es those parts ....

....[14, 15] By contrast, programs compacted using our techniques can be executed directly without any decompression or special hardware support. Most of the previous work on code compaction to yield smaller executables treats an executable program as a simple linear sequence of instructions [3, 6, 12]. They use sux trees to identify repeated instructions in the program and abstract them out into functions. None of these works address the issue of reducing the size of the data section within a program. The size reductions they report are modest, averaging about 4 7 . Clausen et al. 4] applied ....

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. PLDI, pages 139-149, May 1999.

....of programs to reduce their memory footprint while retaining the property that they can be executed directly without requiring any decompression. Work on code compaction has generally focused on identifying repeated instruction sequences within a program and abstracting them into functions [5, 13] or macro instructions in programmable execution environments such as the Java Virtual Machine [4] Work on data compaction is limited to simple literal address removal from object files [19] Whereas program compaction compacts code and data in a program, program extraction identifies those parts ....

....is a su#cient condition, not only for the local use definition relationships to be identical, but also for the global relationships. Global use definition relationships should however not play any role in the renaming of code blocks that have unique entry and exit points. Cooper and McIntosh [5] have proposed renaming basic blocks by globally renaming registers instead of inserting register copy operations. This has the disadvantage that renaming to make one pair of blocks identical can a#ect (even undo) renaming for another pair of blocks. We feel that inserting copy operations is ....

[Article contains additional citation context not shown here]

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. PLDI, pages 139--149, May 1999.

No context found.

COOPER,K.AND MCINTOSH,N. 1999. Enhanced code compression for embedded RISC processors. In Proceedings of the ACM SIGPLAN '99 Conference on Programming Language Design and Implementation. 139--149.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. of the ACM SIGPLAN '99 Conference on Programming Language Design and Implementation, pages 139--149, 1999.

No context found.

Cooper, K. D., and McIntosh, N. Enhanced code compression for embedded RISC processors. In Proc. ACM SIGPLAN Conf. on Programming Languages Design and Implementation (PLDI'99) (May 1999), vol. 34, ACM, pp. 139--149.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. ACM Conf. on Programming Language Design and Implementation, pages 139--149, May 1999.

No context found.

K. D. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. Conf. on Programming Languages Design and Implementation, 1999.

No context found.

K. D. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. Conf. on Programming Languages Design and Implementation, 1999.

No context found.

K. D. Cooper and N. McIntosh, Enhanced code compression for embedded RISC processors, Proc. ACM SIGPLAN '99 Conference on Programming Language Design and Implementation, Atlanta, USA, 1999, 139--149.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In on Programming Language Design and Implementation (PLDI), pages 139--149, 1999.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. 1999.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. ACM Conf. on Prog. Lang. Design and Impl., pages 139--149, May 1999.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. of the ACM SIGPLAN '99 Conference on Programming Language Design and Implementation, pages 139--149, 1999.

No context found.

K. Cooper and N. McIntosh. Enhanced code compression for embedded RISC processors. In Proc. ACM Conf. on Programming Language Design and Implementation (PLDI), pages 139--149, May 1999.

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC