We study the energy efficiency benefits of bypass-
ing trivial computations in high-performance proces-
sors. Trivial computations are those computations
whose output can be determined without performing the
computation. We show that bypassing trivial instruc-
tions reduces energy consumption while improving per-
formance. Our study shows that by bypassing trivial
instructions and for the subset of SPEC’2K benchmarks
studied here, on average, it is possible to improve
energy and energy-delay by up to 4.5% and 11.8% over
a conventional processor.
In this work we improve energy-efficiency in high-
performance processors by bypassing trivial instruc-
tions. A trivial instruction is an instruction whose out-
put can be determined without performing the actual
computation. For such instructions, we can determine
the results immediately based on the value of one or
both of the source operands. Examples are multiply or
add instructions where one of the input operands is
Determining the trivial instruction result without
performing the computation will improve energy-effi-
ciency in two ways: First, it will result in faster instruc-
tion execution. This, consequently, could result in
earlier execution of those instructions depending on the
trivial instruction output. This results in shorter pro-
gram runtime which in turn reduces energy consump-
tion. Second, by bypassing trivial instructions we no
longer spend energy on executing them. As such, we
reduce total energy consumption.
We assume a typical load/store ISA where each
instruction may have up to two source operands. We
refer to the operand which trivializes the operation as
the trivializing operand (TO). Examples of TOs are the
operand equal to zero in an add operation or the oper-
and equal to one in a multiplication.
Previous study shows that a) an optimizing compiler
is often unable to remove trivial operations since trivial
values are not known at compile time and b) the amount
of trivial computations does not heavily depend on pro-
gram specific inputs .
Identifying trivial instructions dynamically is possi-
ble as soon as the TO and the instruction opcode are
known. However, computing the result may not always
require knowledge of both source operands. In some
cases, e.g., multiplying by zero, we do not need both
operands to compute the result. Under such circum-
stances, the result does not depend on the other operand
value. In other cases, e.g., addition to zero, both oper-
ands are needed. We refer to those trivial instructions
whose output could be calculated knowing only one of
the operands as fully-trivial instructions. We refer to
those trivial instructions whose result could be com-
puted only after knowing both operands as semi-trivial
instructions. Our study shows that semi-trivial instruc-
tions account for the majority of trivial instructions.
However, bypassing a fully-trivial instruction can
impact performance and energy more than bypassing a
semi-trivial instruction. This is due to the fact that fully-
trivial instructions can be bypassed earlier and save
more energy as they make reading both operands
Table 1 reports the fully-trivial and semi-trivial com-
putations studied in this work. We report both the oper-
ation and the particular source operand value that
trivializes the operation. It is possible to extend our
study further to include other instruction types (e.g.,
ABS). However, this will not impact our results as such
instructions are very infrequent.
Generally, power-aware techniques save energy at
the expense of performance. Bypassing trivial instruc-
tions, however, reduces energy consumption while
improving performance. Note that computing trivial
instruction results, while unnecessary, results in extra
latency and additional energy consumption. Therefore,
bypassing the computation and obtaining the result
without performing the computation will improve both
performance and energy simultaneously.
In this work we study the energy benefits achieved
by dynamically identifying and bypassing both fully-
trivial and semi-trivial computations. In particular, we
make the following contributions:
Improving Energy-Efficiency by Bypassing Trivial Computations
Ehsan Atoofian and Amirali Baniasadi
ECE Department, University of Victoria
0-7695-2312-9/05/$20.00 (c) 2005 IEEE
Tran et al., evaluated dynamic methods to reduce
pressure on the register file. They explored the impact
of bypassing trivial instructions on the register file pres-
sure . We used their implementation of register
remapping to bypass decode-trivial instructions in this
Chung et al., suggested optimization of embedded
software .They presented software-based techniques
to reduce the computational effort of programs, using
value profiling and partial evaluation. Their tool
reduced the computational effort by specializing fre-
quently executed procedures for the most common val-
ues of their parameters. Their work included
introducing software solutions to replace complex func-
tions which have trivializing operands with more sim-
ple functions. Our work is different as it introduces
dynamic hardware-based optimizations. Dynamic opti-
mizations can be integrated with the microarchitecture
and result in better architectural transparency. As such,
our technique can optimize legacy code without the
need for recompilation.
In this work we showed that it is possible to improve
energy consumption and energy-delay by bypassing
We categorized trivial instructions to fully-trivial
and semi-trivial instructions based on whether both
source operands are needed to decide the result. We
also categorized trivial instructions to decode-trivial
and issue-trivial instruction based on the pipeline stage
that they could be identified at. We showed that semi-
trivial instructions account for the majority of trivial
instructions while, on average, decode-trivial and issue-
trivial instructions each account for almost half of the
total trivial instructions.
Our study showed that by bypassing trivial instruc-
tions, on average, we can improve energy consumption
and energy-delay by 4.5% and 11.8% over a conven-
 D. Burger, T. M. Austin, and S. Bennett. “Evaluating
Future Microprocessors: The SimpleScalar Tool Set”.
Technical Report CS-TR-96-1308,
Wisconsin-Madison, July 1996.
 J. J. Yi and D. J. Lilja, “Improving Processor Performance
by Simplifying and Bypassing Trivial Computations”,
Laboratory for Advanced Research in Computing
Technology and Compilers Technical Report No.
ARCTiC 02-06, June, 2002
 L. Tran, N. Nelson, F. Ngai, S. Dropsho, and M. Huang.
“Dynamically Reducing Pressure on the Physical
Register File through Simple Register Sharing”. In
International Symposium on Performance Analysis of
Systems and Software. March 2004.
 D. Brooks, V. Tiwari M. Martonosi, “Wattch: A
Framework for Architectural-Level Power Analysis and
Optimizations”, In Proceedings
Symposium on Computer Architecture, 2000.
 S. Richardson, Caching Function Results: “Faster
Arithmetic by Avoiding Unnecessary Computation”,
International Symposium on Computer Arithmetic, 1993.
 E. Chung, L. Benini, G. DeMicheli, G. Luculli, and M.
Carilli, “Value-Sensitive Automatic Code Specialization
for Embedded Software”, in IEEE Transactions on
Computer-Aided Design of Integrated Circuits and
Systems, VOL. 21, NO. 9, September 2002
 M. H. Lipasti and J. P. Shen, “Exceeding the dataflow limit
via value prediction”, in Proceedings of the 29th Annual
ACM/IEEE International Symposium and Workshop on
Microarchitecture, pp. 226–237, December 1996.
 A. Sodani and G. S. Sohi. “Dynamic Instruction Reuse”. In
Proc. of 24th Annual International Symposium on
Computer Architecture, pages 194–205, July 1997.
 Hennessy, J. and Patterson, D. Computer Architecture: A
Francisco, CA, 1990, 1996, 2003.
 G. S. Sohi, “Instruction Issue Logic for High-
Performance, Interruptible, Multiple Functional Unit,
Pipelined Computers”, IEEE Trans. on Computers, vol.
39, pp. 349-359, March 1990.
Morgan Kauffman, San
0-7695-2312-9/05/$20.00 (c) 2005 IEEE