Cse 331 computer organization and design fall 2007 week 5
Download
1 / 27

CSE 331 Computer Organization and Design Fall 2007 Week 5 - PowerPoint PPT Presentation


  • 102 Views
  • Uploaded on

CSE 331 Computer Organization and Design Fall 2007 Week 5. Section 1: Mary Jane Irwin ( www.cse.psu.edu/~mji ) Section 2: Krishna Narayanan Course material on ANGEL: cms.psu.edu [ adapted from D. Patterson slides ]. Head’s Up. Last week’s material Supporting procedure calls and returns

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CSE 331 Computer Organization and Design Fall 2007 Week 5' - leola


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Cse 331 computer organization and design fall 2007 week 5

CSE 331Computer Organization and DesignFall 2007Week 5

Section 1: Mary Jane Irwin (www.cse.psu.edu/~mji)

Section 2: Krishna Narayanan

Course material on ANGEL: cms.psu.edu

[adapted from D. Patterson slides]


Head s up
Head’s Up

  • Last week’s material

    • Supporting procedure calls and returns

  • This week’s material

    • Addressing modes; Assemblers, linkers and loaders

      • Reading assignment - PH: 2.10, A.1-A.5

  • Next week’s material (after Exam #1)

    • Introduction to VHDL and basic VHDL constructs

      • Reading assignment – Y, Chapters 1 through 3

  • Reminders

    • HW 4 is due Thursday, Sept 27th (by 11:55pm)

    • Quiz 3 will close Sunday, Sept 30th (at 11:55pm)

    • Exam #1 is Tuesday, Oct 2, 6:30 to 7:45pm, 113 IST


Cdt article on ibm s bluegene p 9 25 07
CDT Article on IBM’s BlueGene/P (9/25/07)

  • Calculations per second

    • Gigaflop 1 billion (1,000,000,000)

    • Teraflop 1 trillion (1,000,000,000,000)

    • Petaflop 1 quadrillion (1,000,000,000,000,000)

    • Exaflop 1 quintrillion (1,000,000,000,000,000,000)


Mips operand addressing modes summary

1. Register addressing

op rs rt rd funct

Register

word operand

2. Base addressing

op rs rt offset

Memory

word or byte operand

base register

3. Immediate addressing

op rs rt operand

MIPS Operand Addressing Modes Summary

  • Register addressing – operand is in a register

  • Base (displacement) addressing – operand’s address in memory is the sum of a register and a 16-bit constant contained within the instruction

  • Immediate addressing – operand is a 16-bit constant contained within the instruction


Mips instruction addressing modes summary

4. PC-relative addressing

op rs rt offset

Memory

branch destination instruction

Program Counter (PC)

5. Pseudo-direct addressing

Memory

op jump address

||

jump destination instruction

Program Counter (PC)

MIPS Instruction Addressing Modes Summary

  • PC-relative addressing – instruction’s address in memory is the sum of the PC and a 16-bit constant contained within the instruction

  • Pseudo-direct addressing – instruction’saddress in memory is the 26-bit constant contained within the instruction concatenated with the upper 4 bits of the PC




Review mips r3000 isa
Review: MIPS R3000 ISA

  • Instruction Categories

    • Load/Store

    • Computational

    • Jump and Branch

    • Floating Point

      • coprocessor

    • Memory Management

    • Special

  • 3 Instruction Formats: all 32 bits wide

Registers

R0 - R31

PC

HI

LO

6 bits

5 bits

5 bits

5 bits

5 bits

6 bits

R format

OP

rs

rd

shamt

funct

rt

I format

rt

16 bit number

OP

rs

J format

26 bit jump target

OP


Risc design principles review
RISC Design Principles Review

  • Simplicity favors regularity

    • fixed size instructions – 32-bits

    • small number of instruction formats

  • Smaller is faster

    • limited instruction set

    • limited number of registers in register file

    • limited number of addressing modes

  • Good design demands good compromises

    • three instruction formats

  • Make the common case fast

    • arithmetic operands from the register file (load-store machine)

    • allow instructions to contain immediate operands


The code translation hierarchy

compiler

assembly code

The Code Translation Hierarchy

C program


Compiler
Compiler

Transforms the C program into an assembly language program

  • Advantages of high-level languages

    • many fewer lines of code

    • easier to understand and debug

  • Today’s optimizing compilers can produce assembly code nearly as good as an assembly language programming expert and often better for large programs

    • smaller code size, faster execution

  • To learn more take CSE 421


The code translation hierarchy1

compiler

assembly code

assembler

object code

The Code Translation Hierarchy

C program


Assembler
Assembler

Does a syntactic check of the code (i.e., did you type it in correctly) and then transforms the symbolic assembler code into object (machine) code

  • Advantages of assembler

    • much easier than remembering instr’s binary codes

    • can use labels for addresses – and let the assembler do the arithmetic

    • can use pseudo-instructions

      • e.g., “move $t0, $t1” exists only in assembler (would be implemented using “add $t0,$t1,$zero”)

  • When considering performance, you should count instructions executed, not code size


The two main tasks of the assembler
The Two Main Tasks of the Assembler

  • Builds a symbol table which holds the symbolic names (labels) and their corresponding addresses

    • A label is local if it is used only within the file where its defined. Labels are local by default.

    • A label is external (global) if it refers to code or data in another file or if it is referenced from another file. Global labels must be explicitly declared global (e.g., .globl main)

  • Translates each assembly language statement into object (machine) code by “assembling” the numeric equivalents of the opcodes, register specifiers, shift amounts, and jump/branch targets/offsets


Mips spim memory allocation
MIPS (spim) Memory Allocation

Memory

f f f f f f f c

Mem Map I/O

Kernel Code & Data

$sp

7f f f f f fc

Stack

230

words

Dynamic data

$gp

1000 8000

Static data

1000 0000

Text

Segment

PC

0040 0000

Reserved

0000 0000


Other tasks of the assembler
Other Tasks of the Assembler

  • Converts pseudo-instr’s to legal assembly code

    • register $at is reserved for the assembler to do this

  • Converts branches to far away locations into a branch followed by a jump

  • Converts instructions with large immediates into a lui followed by an ori

  • Converts numbers specified in decimal and hexidecimal into their binary equivalents and characters into their ASCII equivalents

  • Deals with data layout directives (e.g., .asciiz)

  • Expands macros (frequently used sequences of instructions)


Typical object file pieces
Typical Object File Pieces

  • Object file header: size and position of the following pieces of the file

  • Text (code) segment (.text) : assembled object (machine) code

  • Data segment (.data) : data accompanying the code

    • static data - allocated throughout the program

    • dynamic data - grows and shrinks as needed

  • Relocation information: identifies instructions (data) that use (are located at) absolute addresses – not relative to a register (including the PC)

    • on MIPS only j, jal, and some loads and stores (e.g., lw $t1, 100($zero) ) use absolute addresses

  • Symbol table: global labels with their addresses (if defined in this code segment) or without (if defined external to this code segment)

  • Debugging information


An example
An Example

.data

.align 0

str: .asciiz "The answer is "

cr: .asciiz "\n"

.text

.align 2

.globl main

.globl printf

main: ori $2, $0, 5

syscall

move $8, $2

loop: beq $8, $9, done

blt $8, $9, brnc

sub $8, $8, $9

j loop

brnc: sub $9, $9, $8

j loop

done: jal printf


The code translation hierarchy2

compiler

assembly code

assembler

object code

library routines

linker

executable

The Code Translation Hierarchy

C program

main text segment

printf text segment

machine code


Linker
Linker

Takes all of the independently assembled code segments and “stitches” (links) them together

  • Faster to recompile and reassemble a patched segment, than it is to recompile and reassemble the entire program

  • Decides on memory allocation pattern for the code and data segments of each module

    • Remember, modules were assembled in isolation so each has assumed its code’s starting location is 0x0040 0000 and its static data starting location is 0x1000 0000

  • Relocates absolute addresses to reflect the new starting location of the code segment and its data segment

  • Uses the symbol tables information to resolve all remaining undefined labels

    • branches, jumps, and data addresses to/in external modules

  • Linker produces an executable file


  • Linker code schematic

    Executable file

    main:

    .

    .

    .

    jal printf

    printf:

    .

    .

    .

    Linker Code Schematic

    Object file

    main:

    .

    .

    .

    jal ????

    call, printf

    Linker

    C library

    printf:

    .

    .

    .

    Relocation info


    Linking two object files
    Linking Two Object Files

    Executable

    File 1

    +

    File 2

    Hdr Txtseg Dseg Reloc

    Hdr Txtseg Dseg Reloc Smtbl Dbg

    Hdr Txtseg Dseg Reloc Smtbl Dbg


    The code translation hierarchy3

    compiler

    assembly code

    assembler

    object code

    library routines

    linker

    executable

    loader

    memory

    The Code Translation Hierarchy

    C program

    machine code


    Loader
    Loader

    • Loads (copies) the executable code now stored on disk into memory at the starting address specified by the operating system

    • Copies the parameters (if any) to the main routine onto the stack

    • Initializes the machine registers and sets the stack pointer to the first free location (0x7fff fffc)

    • Jumps to a start-up routine (at PC addr 0x0040 0000 on xspim) that copies the parameters into the argument registers and then calls the main routine of the program with a jal main

    • To learn more take CSE 311 and CSE 411


    Dynamically linked libraries
    Dynamically Linked Libraries

    • Statically linking libraries mean that the library becomes part of the executable code

      • It loads the whole library even if only a small part is used (e.g., standard C library is 2.5 MB)

      • What if a new version of the library is released ?

    • (Lazy) dynamically linked libraries (DLL) – library routines are not linked and loaded until a routine is called during execution

      • The first time the library routine called, a dynamic linker-loader must

        • find the desired routine, remap it, and “link” it to the calling routine (see book for more details)

      • DLLs require extra space for dynamic linking information, but do not require the whole library to be copied or linked


    First evening exam
    First Evening Exam

    • Exam #1: Tuesday, Oct 2, 6:30 to 7:45pm, 113 IST

      • Look at the practice exam (and solutions) on ANGEL

      • In Section 1 – two people requesting a conflict exam

      • In Section 2 – one person requesting a conflict exam

    • Questions?