Designing an Open Database of System-Aware Code Optimizations

2017 ◽  
Author(s):  
Ryusuke Egawa ◽  
Kazuhiko Komatsu ◽  
Hiroyuki Takizawa
Keyword(s):  
Code Optimizations

scholarly journals An Empirical Investigation on System and Statement Level Parallelism Strategies for Accelerating Scatter Search Using Handel-C and Impulse-C

VLSI Design ◽  
2012 ◽  
Vol 2012 ◽  
pp. 1-11
Author(s):  
M. Walton ◽  
O. Ahmed ◽  
G. Grewal ◽  
S. Areibi
Keyword(s):  
Optimization Problems ◽  
Scatter Search ◽  
Population Based ◽  
Field Programmable ◽  
Speed Up ◽  
Time Required ◽  
High Level ◽  
Level Parallelism ◽  
Code Optimizations ◽  
Established Population

Scatter Search is an effective and established population-based metaheuristic that has been used to solve a variety of hard optimization problems. However, the time required to find high-quality solutions can become prohibitive as problem sizes grow. In this paper, we present a hardware implementation of Scatter Search on a field-programmable gate array (FPGA). Our objective is to improve the run time of Scatter Search by exploiting the potentially massive performance benefits that are available through the native parallelism in hardware. When implementing Scatter Search we employ two different high-level languages (HLLs): Handel-C and Impulse-C. Our empirical results show that by effectively exploiting source-code optimizations, data parallelism, and pipelining, a 28x speed up over software can be achieved.

Code optimizations for a VLIW-style network processing unit

2004 ◽  
Vol 34 (9) ◽  
pp. 847-874
Author(s):  
Jinhwan Kim ◽  
Yunheung Paek ◽  
Gangryung Uh
Keyword(s):  
Processing Unit ◽  
Code Optimizations ◽  
Network Processing

scholarly journals A Class-Specific Optimizing Compiler

1993 ◽  
Vol 2 (4) ◽  
pp. 235-238
Author(s):  
Michael D. Sharp ◽  
Steve W. Otto
Keyword(s):  
Strength Reduction ◽  
Compiler Optimizations ◽  
Optimizing Compiler ◽  
C Compiler ◽  
Code Optimizations

Class-specific optimizations are compiler optimizations specified by the class implementor to the compiler. They allow the compiler to take advantage of the semantics of the particular class so as to produce better code. Optimizations of interest include the strength reduction of class:: array address calculations, elimination of large temporaries, and the placement of asynchronous send/recv calls so as to achieve computation/communication overlap. We will outline our progress towards the implementation of a C++ compiler capable of incorporating class-specific optimizations.

Code optimizations for lazy evaluation

1988 ◽  
Vol 1 (2) ◽  
pp. 147-164 ◽  
Author(s):  
Adrienne Bloss ◽  
Paul Hudak ◽  
Jonathan Young
Keyword(s):  
Lazy Evaluation ◽  
Code Optimizations

Code optimizations using formally verified properties

2013 ◽  
Vol 48 (10) ◽  
pp. 427-442
Author(s):  
Yao Shi ◽  
Bernard Blackham ◽  
Gernot Heiser
Keyword(s):  
Code Optimizations

scholarly journals Actionable Program Analyses for Improving Software Performance

2020 ◽  
pp. 113-140
Author(s):  
Marija Selakovic
Keyword(s):  
Software Development ◽  
Performance Improvement ◽  
Constant Pressure ◽  
Software Performance ◽  
Limited Knowledge ◽  
Significant Performance ◽  
Code Changes ◽  
Performance Analyses ◽  
Performance Issues ◽  
Code Optimizations

AbstractNowadays, we have greater expectations of software than ever before. This is followed by the constant pressure to run the same program on smaller and cheaper machines. To meet this demand, the application’s performance has become an essential concern in software development. Unfortunately, many applications still suffer from performance issues: coding or design errors that lead to performance degradation. However, finding performance issues is a challenging task: there is limited knowledge on how performance issues are discovered and fixed in practice, and current profilers report only where resources are spent, but not where resources are wasted. In this chapter, we investigate actionable performance analyses that help developers optimize their software by applying relatively simple code changes. We focus on optimizations that are effective, exploitable, recurring, and out-of-reach for compilers. These properties suggest that proposed optimizations lead to significant performance improvement, that they are easy to understand and apply, applicable across multiple projects, and that the compilers cannot guarantee that these optimizations always preserve the original program semantics. We implement our actionable analyses in practical tools and demonstrate their potential in improving software performance by applying relatively simple code optimizations.

Sign in / Sign up

Export Citation Format

Share Document