EE 7700-1 - Procedures

Account Setup (Updated Spring 2007)

To Setup Account for use with Shade, PSE and Other Software

Account Setup (Updated Spring 2007)

To Setup Account for use with Shade, PSE and Other Software

The instructions below setup your account so that it can use the PSE simulation viewer, the Shade analysis package, and the Emacs initialization file. (Shade must be run from a Sun machine.) (Yes, running from a Sun or Linux machine sets up both the Sun and Linux accounts.)

Beware, these steps have not been checked recently. Please report any problems immediately.

Log in to your account. You can log into either a Sun or Linux machine, preferably Linux. If you log into a Sun, when prompted select Common Desktop Environment.
If you select Open Windows by mistake, log out then select Common Desktop Environment from the Sessions control on the login dialog.
Start a shell (command-line interpretor) if one is not already running. One way to do this on a Sun (CDE) is to right-click on the desktop and choose "Terminal" from the pop-up menu. From Linux (GNome) select the terminal icon.
Enter the command:
```
/home/classes/ee4720/com/bin/setup
```
This copied files in to your account, including .cshrc (initializations for the shell), .emacs (initializations for Emacs, which you don't have to use), and initializations for the CDE window manager to display the PSE icon.
It should print the message "Finished copying files...". If you have your own copy of one of these files and its different a warning will be printed and nothing will be copied. Note that files are kept in the EE 4720 class directory even though they are not necessarily for that course.
Log out, then log back in.
To see if it worked, follow the procedure for using PSE.

Homework Assignments

Homework 1, Spring 2007

Follow instructions above for setting up your class account.
Read the assignment.
Log into the account on a Linux system.
Start Firefox and load /home/faculty/koppel/pub/ds/2007/batch.sm.0098/index.html
```
firefox /home/faculty/koppel/pub/ds/2007/batch.sm.0098/index.html
```
Click on a link to start pse on the corresponding simulation dataset.

Running PSE

Background

PSE is a program for graphically viewing the output of CPU simulators. For instructions on running PSE see EE 4720 Procedures page.

Emacs Text Editor (Fall 2003)

Using Emacs to Edit a File

Type emacs & or click the kitchen-sink icon. A window should pop up, the frame will be labeled Emacs. If the .emacs file was copied correctly there will be an "EE3755" pull-down menu. This menu is not relevant to this class.
Load a file by selecting "Open File..." from the Files menu.
Enter a file name. Note that text appears in the bottom of the main window in an area called the minibuffer, not in a dialog box. (Once loaded, the file name will appear in the mode line near the bottom of the window.)
Enter text in the buffer to try out the editor.
Select "Save Buffer" from the Files menu to save.
Select "Exit Emacs" from Files to exit.

Using Emacs to Edit C

Special features for editing C code. (Some work with other languages.)

Load a C file into a buffer. Enter C code (any C code). Code should be syntax highlighted, alerting you to some syntax errors and giving you something pretty to look at.
Pressing tab will automatically indent the line the cursor is over. This is useful for catching syntax errors and keeping the description properly indented.
Pressing F9 will build the program (using the Makefile that is in the directory). A window will open showing the compiler output. Clicking on an error message with the center mouse button will move the cursor to the line with the error.

Running the Emacs Tutorial

(The tutorial is an introduction for first-time users.)

Start emacs.
Select "Emacs Tutorial" from the "Help" menu. Do not attempt to learn everything the first day.

Starting Info, Emacs' Help

(Info provides detailed documentation for Emacs and other programs.)

Start Emacs
Select "Browse Manuals" from "Help" menu.
Following instructions, select the Emacs manual.

Using Shade (Fall 2003)

Background

Shade is a package for analyzing the dynamic instruction stream of SPARC (Sun) programs running on Solaris. Analysis can be simple, such as counting the number of load instructions executed, of moderate complexity, such as evaluating the prediction accuracy of a branch predictor, or complex, such as determining the performance of a particular pipelined implementation.

Shade comes with several analyzers, programs for analyzing instruction streams, and users can write their own. See the Shade User's Manual for documentation on analyzers that come with Shade.
For a typical homework assignment one will have to modify an existing analyzer, or perhaps write a new one. A set of files will be provided for each homework assignment, including analyzer source code and a makefile.

For instructions on running and writing analyzers see the Introduction to Shade.
For details see the Shade User's Manual.

Running Shade

Shade is run to analyze (perhaps simulate) a benchmark program. This step is performed after an analyzer has been compiled and suitable benchmarks chosen. The steps below are for the icount (instruction count) analyzer and the pwd program, both of which should be available if the class account was set up correctly.

Start a shell if none is already handy. In Emacs this can be done with the command M-x shell.
The advantage of using Emacs is the ease of scrolling back to look at lengthy output. It may also be easier to cut and paste portions of the output you want to save.

Run the analyzer and provide the name of the benchmark and any arguments to stdin. An easy way to do that is:

echo pwd | icount

Analyzer: icount
Version: Shade and Spixtools V5.33A, V9 SPARC Solaris
Uname: drop sun4u SunOS 5.8 Generic_108528-24
Start: Mon Nov 10 16:17:03 2003
Application: /bin/pwd
/home/faculty/koppel/teach/tca03/shade/hw3
Application Instructions: 557466
Stop: Mon Nov 10 16:17:04 2003
Instructions: 557466
Time: 0.060 usr  0.010 sys  0.140 real  49.978%
Speed: 7963.800 KIPS

The text "pwd" is read by the icount analyzer, which then runs it (the pwd program). Instead of using echo and a pipe, one could enter:
icount pwd

Running the Instruction Tracing Utility

The instruction tracing utility is a shade analyzer that shows the instructions executed by, traces, a program. By default it shows the first ten instructions, but it can show any number. Each of the steps below shows a different way of using it, the first step describes the tracer's output.

Show the first ten instructions of a program named sum. But first, here is the output of sum:

sum

Hello.0.000000 
Sum in: 45  0.000000

Here is the traced output of sum. The output of sum comes first, followed by the trace output. (Other times the trace and the traced program output will be mixed.)

echo sum | rtrace

Hello.0.000000 
Sum in: 45  0.000000
_start+0  :
 Insn Num  Insn PC    Assembler                ! Register and Other Values
        1  0x00010078 or     %g0,0,%fp         ! 0x0,0,0x0
        2  0x0001007c lduw   [%sp+64],%l0      ! [0xffffcbc0+64],0x1
        3  0x00010080 add    %sp,68,%l1        ! 0xffffcbc0,68,0xffffcc04
        4  0x00010084 sub    %sp,32,%sp        ! 0xffffcbc0,32,0xffffcba0
        5  0x00010088 orcc   %g0,%g1,%g0       ! 0x0,0x0,0x0
        6  0x0001008c be     0x1009c (_start+9  )  ! 
        7  0x00010090 or     %g0,%g1,%o0       ! 0x0,0x0,0x0
_start+9  :
        8  0x0001009c sethi  %hi(0x32800),%o0  ! %hi(0x32800),0x32800
        9  0x000100a0 or     %o0,904,%o0       ! 0x32800,904,0x32b88
       10  0x000100a4 call   0x102e8 (atexit+0  )  !
Executed 3241 instructions.

The Insn Num is a numbering of dynamic instructions. The PC of each instruction is shown, line labels are shown (_start+0 and _start+9 above) at the target of taken control transfers, the amount of information depends on how the program being analyzed was built. Register values are shown as comments.

To trace 20 instructions starting at instruction number 1000:

echo sum | rtrace 1000 20

Hello.0.000000 
Sum in: 45  0.000000
_doprnt+1283  :
 Insn Num  Insn PC    Assembler                ! Register and Other Values
     1000  0x00011bb0 add    %i4,1,%i4         ! 0x0,1,0x1
     1001  0x00011bb4 add    %i3,1,%i3         ! 0xffffc370,1,0xffffc371
     1002  0x00011bb8 ba     0x11bcc (_doprnt+1290  )  ! 
     1003  0x00011bbc lduw   [%sp+152],%o1     ! [0xffffbd08+152],0x30
_doprnt+1290  :
     1004  0x00011bcc lduw   [%sp+92],%o0      ! [0xffffbd08+92],0xffffc592
     1005  0x00011bd0 stb    %o1,[%o0]         ! 0x30,[0xffffc592]
     1006  0x00011bd4 add    %o0,1,%o0         ! 0xffffc592,1,0xffffc593
     1007  0x00011bd8 lduw   [%sp+184],%g1     ! [0xffffbd08+184],0x5
     1008  0x00011bdc stw    %o0,[%sp+92]      ! 0xffffc593,[0xffffbd08+92]
     1009  0x00011be0 subcc  %g1,1,%o0         ! 0x5,1,0x4
     1010  0x00011be4 stw    %o0,[%sp+184]     ! 0x4,[0xffffbd08+184]
     1011  0x00011be8 bpos,a 0x11b80 (_doprnt+1271  )  ! 
     1012  0x00011bec lduw   [%fp-1228],%o0    ! [0xffffca40-1228],0x1
_doprnt+1271  :
     1013  0x00011b80 add    %o0,1,%o0         ! 0x1,1,0x2
     1014  0x00011b84 subcc  %o0,0,%g0         ! 0x2,0,0x0
     1015  0x00011b88 ble    0x11bc0 (_doprnt+1287  )  ! 
_doprnt+1274  :
     1016  0x00011b8c stw    %o0,[%fp-1228]    ! 0x2,[0xffffca40-1228]
     1017  0x00011b90 ldsb   [%i3],%o0         ! [0xffffc371],0x30
     1018  0x00011b94 subcc  %o0,0,%g0         ! 0x30,0,0x0
     1019  0x00011b98 be,a   0x11bc4 (_doprnt+1288  )  ! 
Executed 1019 instructions.

To execute the first 20 instructions of routine main:

echo sum | rtrace 20 main

Hello.0.000000 
Sum in: 45  0.000000
main+0  :
 Insn Num  Insn PC    Assembler                ! Register and Other Values
       94  0x0001020c save   %sp,-128,%sp      ! 0xffffcba0,-128,0xffffcb20
       95  0x00010210 stw    %i0,[%fp+68]      ! 0x1,[0xffffcba0+68]
       96  0x00010214 stw    %i1,[%fp+72]      ! 0xffffcc04,[0xffffcba0+72]
       97  0x00010218 stw    %g0,[%fp-24]      ! 0x0,[0xffffcba0-24]
       98  0x0001021c sethi  %hi(0x4ac00),%o1  ! %hi(0x4ac00),0x4ac00
       99  0x00010220 or     %o1,904,%o0       ! 0x4ac00,904,0x4af88
      100  0x00010224 sethi  %hi(0x2400),%o2   ! %hi(0x2400),0x2400
      101  0x00010228 or     %o2,784,%o1       ! 0x2400,784,0x2710
      102  0x0001022c stw    %o1,[%o0] (traceamt)  ! 0x2710,[0x4af88+0x0]
      103  0x00010230 stw    %g0,[%fp-20]      ! 0x0,[0xffffcba0-20]
      104  0x00010234 lduw   [%fp-20],%o0      ! [0xffffcba0-20],0x0
      105  0x00010238 subcc  %o0,9,%g0         ! 0x0,9,0x0
      106  0x0001023c ble    0x1024c (main+16  )  ! 
      107  0x00010240 nop                      ! 
main+16  :
      108  0x0001024c lduw   [%fp-24],%o0      ! [0xffffcba0-24],0x0
      109  0x00010250 lduw   [%fp-20],%o1      ! [0xffffcba0-20],0x0
main+18  :
      110  0x00010254 add    %o0,%o1,%o0       ! 0x0,0x0,0x0
      111  0x00010258 stw    %o0,[%fp-24]      ! 0x0,[0xffffcba0-24]
      112  0x0001025c lduw   [%fp-20],%o0      ! [0xffffcba0-20],0x0
      113  0x00010260 add    %o0,1,%o1         ! 0x0,1,0x1
Executed 3241 instructions.

To trace for five instructions whenever global variable traceamt in sum is assigned or referenced, with a limit of 20 instructions:

echo sum | rtrace traceamt 5 20

Hello.0.000000 
Sum in: 45  0.000000
main+8  :
 Insn Num  Insn PC    Assembler                ! Register and Other Values
      102  0x0001022c stw    %o1,[%o0] (traceamt)  ! 0x2710,[0x4af88+0x0]
      103  0x00010230 stw    %g0,[%fp-20]      ! 0x0,[0xffffcba0-20]
      104  0x00010234 lduw   [%fp-20],%o0      ! [0xffffcba0-20],0x0
      105  0x00010238 subcc  %o0,9,%g0         ! 0x0,9,0x0
      106  0x0001023c ble    0x1024c (main+16  )  ! 
main+27  :
      242  0x00010278 stw    %g0,[%o0] (traceamt)  ! 0x0,[0x4af88+0x0]
      243  0x0001027c ldf    [%fp+68], f2      ! [0xffffcba0+68],
      244  0x00010280 fitod   f2, f4           ! ,
      245  0x00010284 stdf    f4,[%fp-16]      ! ,[0xffffcba0-16]
      246  0x00010288 ldd    [%fp-16],%o2      ! [0xffffcba0-16],0x0
Executed 3241 instructions.

Compiling a Shade Analyzer

You've got to know if code ever uses subcc with a non-zero destination register. Or maybe you've figured out a solution to the homework assignment. Either way you need to write and run an analyzer, follow the steps below.

Write an analyzer program from scratch, including the makefile. Or, start with an existing analyzer (that might have been provided as part of the homework assignment), and edit it.

Build the analyzer by running the make file. On Emacs this can be done by pressing F9 while in a buffer visiting the analyzer source file, from the shell:

make

gcc -I/data4/koppel/shadekit/shade.v9.elf/src/include -I/data4/koppel/shadekit/shade.v9.elf/spixtools/src/include -g -c pred.c
gcc -dn -Wl,-M,/data4/koppel/shadekit/shade.v9.elf/lib/mapfile -o pred pred.o /data4/koppel/shadekit/shade.v9.elf/lib/libshade.a /data4/koppel/shadekit/shade.v9.elf/spixtools/lib/libspix.a

Your output may include error messages. If you build by pressing F9 then you can jump to an error by clicking the error message with the mouse button.

That's it. To run the analyzer follow the instructions for running Shade.

David M. Koppelman - koppel@ece.lsu.edu

Modified 1 Mar 2007 10:31 (1631 UTC)