CSE 410 Computer Systems - Midterm Topics - Spring 2009

CSE Home

About Us

Search

Contact Info

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 may bring a single sheet of paper with whatever handwritten notes you wish. 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 and jumps.
  • 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 and .data, 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. There are several conventions for how the argument build area should be organized - know how to use the convention described in the slides where the bottom 4 words of a stack frame are reserved for the called function's use as a backing store for values transmitted in $a0 through $a3.
  • 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.
• 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.)
• Memory heirarchy
  • Understand the reasons behind the memory hierarchy (slow and cheap vs. expensive and fast).
  • Understand the ideas behind temporal and spatial locality, why programs exhibit these properties, and how they can be exploited to create large memories with fast effective access times.
  • You do not need to know details of caches, associativity, replacement algorithms, and so forth for the midterm. That will be covered in a future homework assignment and will be one of the possible topics for the final exam.

	Computer Science & Engineering University of Washington Box 352350 Seattle, WA  98195-2350 (206) 543-1695 voice, (206) 543-2969 FAX [comments to Hal Perkins]