CSE 410 Sp07 Midterm Exam Topics

This is a checklist of topics that could be included on the midterm exam. In general you are responsible for everything covered in class and on homework assignments. You are not responsible for specific readings in the textbook, but you are expected to know the material in the book related to topics covered in class.

The exam is closed-book, no notes, no calculators or other electronic devices. You can use the MIPS reference "green card" from the book. Copies of this will be provided if you do not bring your own. In general you should not be memorizing details that you can look up, like instruction op codes or formats, or ASCII character codes.

• Information representation and memory organization.
  • Basics of memory organization: bits, bytes, words. Addresses vs contents of memory locations. Aligned vs. unaligned data (what does that mean?). Big endian vs little endian.
  • Representation of information as bits. Representation of characters (don't memorize the ASCII table, but be able to use it).
  • Integer representation (both unsigned and 2's complement signed numbers).
  • Be able to convert between binary, hexadecimal, and decimal integer representations.
  • Be able to do basic arithmetic using binary or hexadecimal integers, including computing the 2's complement of a binary number.
  • You are not responsible for being able to convert floating point numbers to and from IEEE binary floating point format, but you should understand the basics of floating point representation, including terms like mantissa and exponent, and the implications of calculating with finite precision, floating-point numbers. You should know what the various fields of a floating-point number are and how they are used.
• Representation of programs as machine instructions
  • Understand the basic MIPS instruction set, particularly register-register computations (including logical operations and shifts), load/store instructions, and conditional/unconditional branches.
  • Know the difference between signed and unsigned arithmetic, and load instructions with and without sign-extension, and when to use which ones.
  • Be able to read and write small assembly language programs.
  • Be able to convert between symbolic assembly language instructions and binary (or hex) machine language instructions; know the basic MIPS machine-language formats (R, I, J).
  • Understand how addresses and immediate values are represented in instructions and how addresses are computed (addressing modes).
  • Know the difference between pseudo-instructions that are part of the MIPS assembly language (like move, li and some of the compare instructions) and the underlying machine instructions, and be able to translate between the two.
  • Know the purpose of the basic assembly language directives .text, .data, .globl, and the directives for creating constant data in a program, particularly .asciiz, .byte, and .word.
  • Be able to trace execution of MIPS code and show its effect on register and memory values.
• MIPS programming conventions
  • Know the basic layout of programs in memory (text/code, data, and stack segments)
  • Understand the standard conventions for register usage, which registers have special purposes in the architecture, which are generally available, etc.
  • Know the standard conventions for function (procedure) calls: How arguments and results are transmitted, which registers need to be saved and restored, how control is transferred to a function, where the return address is stored and how control is returned, etc.
  • Know how stack frames are organzied; where registers, local variables, and arguments are stored in them, and how and when they are allocated and released.
  • Understand the use of the syscall instruction to request system services. You don't need to memorize the various argument codes (write integer, write string, etc.), but be able to use them if they are given to you.
• Assemblers and linkers
  • Understand the issues involved in separate assembly (compilation), and linking separately assembled routines together, including how the assembler and linker resolve internal and external labels to actual machine addresses.
  • Understand how libraries are used to store functions, and how the linker combines appropriate parts of libraries with given code to produce executable files.
• Processor organization - pipelining
  • Know the steps involved in instruction execution (IF, ID, EX, MEM, WB)
  • Understand how a pipeline overlaps execution of instructions.
  • Know what execution latency and throughput are.
  • Know the basic kinds of hazards or dependencies that can interfer with pipeline execution (structural, data dependencies, control dependencies).
  • Understand techniques for improving pipeline throughput to deal with hazards (instruction reordering, data forwarding, branch delay slots, branch prediction, etc.)