Shade: A Fast Instruction-Set Simulator for Execution Profiling

[I'm sending this to individuals who expressed interest and to
  several mailing lists. My apologies if you see this note twice.]


Bob Cmelik and I have written a paper about a combined fast
instruction-set simulator and extensible tracing tool. The paper is
now available as a Sun Laboratories, Inc. technical report (TR 93-12)
and as a University of Washington technical report (UWCSE TR 93-06-06).


Probably the easiest way to get the paper is to ftp the compressed
PostScript(tm) from the UW ftp server, `ftp.cs.washington.edu'
(128.95.1.4); it is in `tr/1993/06/UW-CSE-93-06-06.PS.Z'. Be sure to
do the transfer in binary (image) mode.


Alternatives include: send me e-mail (pardo@cs.washington.edu) and I
can e-mail you the PostScript; or tell me your postal address and I
will try to have a printed version sent to you.


Shade provides, in one tool, features that are not generally available
in combination from other such tools: it is fast; it is cross-machine
and can trace programs compiled for hardware that does not yet exist;
Shade correctly executes self-modifying code including
dynamically-linked libraries; it correctly handles signals and
exceptions; executables can be run directly without source code or any
special preprocessing; the level of tracing detail can be changed
dynamically; Shade knows how to collect information that is more
detailed than just an address trace, and is thus useful for e.g.,
pipeline and register file studies; Shade is extensible so analyzers
can have access to arbitrary state in the simulated machine.


The paper is about the implementation of the tool Shade and about
instruction set emulation. The abstract for the paper is reprinted
below. There are also user manuals and one version of the tool is
available, albeit with some terms; if you are interested in more
information about using the tool, send me e-mail and I will forward it
to somebody who can give you more information.


ABSTRACT


              Shade is an instruction-set simulator and custom trace
              generator. Application programs are executed and
              traced under the control of a user-supplied trace
              analyzer. To reduce communication costs, Shade and the
              analyzer are run in the same address space. To further
              improve performance, code which simulates and traces
              the application is dynamically generated and cached for
              reuse. Current implementations run on SPARC systems
              and, to varying degrees, simulate the SPARC (Versions 8
              and 9) and MIPS I instruction sets. This paper
              describes the capabilities, design, implementation, and
              performance of Shade, and discusses instruction set
              emulation in general.


              Shade improves on its predecessors by providing their
              various tracing capabilities together in a single tool.
              Shade is also fast: Running on a SPARC and simulating a
              SPARC, SPEC 89 benchmarks run about 2.3 times slower
              for floating-point programs and 6.2 times slower for
              integer programs. Saving trace data costs more, but
              Shade provides fine control over tracing, so users pay
              a collection overhead only for data they actually need.
              Shade is also extensible so that analyzers can examine
              arbitrary target state and thus collect special infor-
              mation that Shade does not know how to collect.




If you have questions or comments, please e-mail to me directly
(pardo@cs.washington.edu).


;-D on ( Sim you later! ) Pardo
--

Return to the comp.compilers page.
Search the comp.compilers archives again.