Dismiss
InnovationQ will be updated on Sunday, Oct. 22, from 10am ET - noon. You may experience brief service interruptions during that time.
Browse Prior Art Database

Implementing Trace-Directed Program Restructuring for Global Data at the Postprocessing Level

IP.com Disclosure Number: IPCOM000111274D
Original Publication Date: 1994-Feb-01
Included in the Prior Art Database: 2005-Mar-26
Document File: 2 page(s) / 65K

Publishing Venue

IBM

Related People

Heisch, RR: AUTHOR

Abstract

The technique of Trace-Directed Program Restructuring (TDPR) is a well-known method for reorganizing the instructions in a program, based on an address trace of the actual execution of that program, so as to improve the utilization of the instruction cache (which typically results in improved performance) as well as the utilization of real memory (which typically results in a reduction in real memory requirements for virtual memory systems). TDPR can be extended to include reorganization of data objects as well.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 52% of the total text.

Implementing Trace-Directed Program Restructuring for Global Data
at the Postprocessing Level

      The technique of Trace-Directed Program Restructuring (TDPR) is
a well-known method for reorganizing the instructions in a program,
based on an address trace of the actual execution of that program, so
as to improve the utilization of the instruction cache (which
typically results in improved performance) as well as the utilization
of real memory (which typically results in a reduction in real memory
requirements for virtual memory systems).  TDPR can be extended to
include reorganization of data objects as well.

      TDPR can be implemented in one of two ways:  as a standalone
post processing tool and as an integral part of the compiler/linker.
TDPR is much easier to perform as a part of the compiler because of
the need for internal compiler knowledge (such as instruction and
data location, instruction reference information, basic block
identification, etc.), but the implementation may rather severely
impact compiler development.  A standalone postprocessing tool does
not impact compiler development, but is quite difficult to implement
without access to this internal compiler knowledge.

      In particular, reorganizing data objects requires that all
instructions referencing those objects be correctly adjusted as well.
Without knowledge of which instructions reference which data objects,
this is an extremely difficult (if not impossible) task to achieve.
The required information could be added as "meta data" to the
executable file, but would again result in modifications to the
compiler....