CIS360: Reading List Guide

Check the class schedule for reading assignments. The list below is in chapter order - it is not necessarily the order you should be reading the material for this class. Hopefully, this guide will be expanded as the quarter progresses, so refer to it periodically.

Chapter 1
It is very important that you understand the basic fact that everything in a computer is ultimately represented by a sequence of 0's and 1's. If that doesn't sink in, you're going to have a rough time in this class. This first chapter introduces that concept.
- Section 1.1
  Read all of it. Particularly important, if you don't have a good handle on it already, is the concept of positional number systems. The stuff about non-positional number representations should be read and understood, but is only used to introduce positional number representations. You will be doing a lot of converting between bases in this class. You should be able to convert between any two bases I give you, but particularly important is conversion between bases 2, 8, 10, and 16.
- Section 1.2
  It is very important that you understand this section. 2's complement is especially important and is what all computers use. sign-magnitude and BCD are less important in practice, but it's important to understand that alternative representations are possible and have some use.
- Section 1.3
  It is very important that you understand this section. Almost all computers use the ASCII code to represent characters. You will probably be referring to Table 1.7 often. The Huffman code is less important for this class, but is something you periodically will run into as a computer programmer/scientist.
- Section 1.4
  Error correction/detection, parity, and Hamming distance are all important for dealing with digital information. They are more important for CIS675 and beyond than for this class, although we will refer to parity bits later on the class.
Chapter 3 This Chapter is very important to understanding how a computer acutally operates. Although a simple diagram, Figure 3.1 is the starting point for understanding how a computer operates.
- Section 3.1
  The first part of this section is a fairly important section on types of memory and memory organization. It is probably more useful in practice (and for CIS675) than it is for this course, but it is still good stuff to know. The diagrams and discussion that refer to the actual and-gate configurations to use of this or that purpose can be skipped. The main sections to read are: 3.1.1, 3.1.2, and 3.1.4 (but skip Memory Banks discussion).
- Section 3.2
  Here we really get down to how a computer actually computes - at least at the level above the logic gate level. Assuming there's some EE guy to build adders, multiplexors, etc., this section explains how those units can be combined and controlled by signals in the CPU to carry out an assembler instruction. It's very important to understand howinstructions are represented in the computer. 3.2.2 and the first part of 3.2.3 are the central points of this Chapter. It is very important that you understand Table 3.7
- Section 3.3
  This Section we will come back to at the end of the course. Mainly, it introduces some important terms such as memory-mapped I/O and isolated I/O.
Chapter 4
- Section 4.1
  Read all of this. Various assemblers in the past have been based on all of these instruction formats and they all have their advantages (although some advantages have faded with increase processor speed and decrease cost).
- Section 4.2
  Very important. Most assemblers these days fall into the 1 1/2 address or LOAD/STORE categories. The use of registers is fundamental to all processors. Also introduced is the more advanced topic of memory latency and instruction overlapping. These are important in understanding how RISC processors are optimized for speed.
- Section 4.3
  It's important to know the size of information you're dealing with: bytes, halfwords, words, or double words. You have to be aware of how much space values take up in order to optimize the use of memory. Even though it's relatively cheap these days, it's still important to get large programs to execute in minimal memory, especially when dealing with tens of thousands or millions of instructions and data.
- Section 4.4
  This starts some discussion about the various ways to specify operands: memory address, register, immediate value. This is where it starts to become important to understand the bit fields necessary in a machine language instruction to support various addressing options in the assembly language statement.
- Section 4.5
  Flow of control is another important topic in assembler language programming. The book first introduces compare and brance instructions followed by the use of condition codes. The former is easier to understand, but the latter is typcially how things are done (as is how things are done in the SPARC assembler). As the book points out, condition codes are usually used in order to reduce the length of branch instructions and condition codes can be automatically set by the ALU so there is no cost associated with using condition codes.
- Section 4.6
  Bit manipulation instructions are very useful for packing information into bit fields within a byte or word. They are also useful for converting numeric (ASCII) characters into their binary number representation (as you'll see on one of the labs).
Chapter 5
- Section 5.2
  This describes addressing modes and is fairly important to understand. You have to get used to 1) using addresses in registers to access memory and 2) doing simple address arithmetic, like adding displacement values, to addresses. ISEM supports several of the addressing modes mentioned, specifically register (direct), register indirect, indexed register, and register displacement. Understand effective address, how to program arrays including multi-dimensional arrays, stacks, linked lists, and queues.
Chapter 6
- Section 6.1
  This covers the branch and link, or jump, to subroutine. It is important to understand the basics of subroutine linkage because it gets more complicated. Specifically note that the return address often has to be explicity dealt with. Remember that call and retl in SPARC are branch instructions and need a nop following them to be safe.
- Section 6.2
  Basic parameter passing is dicussed. This is important to understand, epsecially the distinction between pass-by-value and pass-by-reference.
- Section 6.4
  The parameter block is used for more extensive parameter passing. The use of pointers to this block is important to get straight.
- Section 6.5
  The parameter stack (and the system stack in general) is very important to all subroutine linkage. It gets a little complicated, but the stack frame is important to understand - see Figure 6.8 on page 227.
Chapter 7
- Section 7.2
  Primarily, The use of a binary adder for 2-s complement addition and subtraction, together with how the condition codes (N,V,Z,C) are set is covered. Double precision addition, multiplication and division of binary numbers are briefly covered. Seccondarily, comparison to 1's complement, excess notation, signed-magnitude, BCD, and ASCII representations of numbers should be noticed.
Chapter 11
- Section 11.0
  The BIOS routines buffer the application program from the system resources to prevent user error or abuse.
- Section 11.1
  The resident monitor are the BIOS routines always in memory allocated to them. The typical way they are accessed is via a dispatch routine using vectored linking using a branch table of some sort. XOPs (extended operations), traps, software interrupts, syscalls, SVCs are all the same thing - explicit requests by the application routine for a system resource. These are similar to subroutine calls except the entire status of the CPU has to be saved (e.g., PSW including condition codes, possibly use a separate set of registers and a separate stack).
- Section 11.2
  The main point about access control is the difference between supervisor mode and user mode.
- Section 11.3
  Exceptions are error condiations. They execute in supervisor mode, although it's not unusual to have user-supplied exception handlers. The exception mechanism can also be used to implement breakpoint debugging.
Chapter 12
- Section 12.1
  Programmed I/O using a UART is discussed. A UART provides a single byte hardware inteface for I/O devices. Simple program segements are given to read and write a byte to/from the UART.
- Section 12.2
  An application program is interrupted by the external interface and the interrupt handler reads a character from the UART. See Figure 12.3. An application, when it reads a character with an XOP (trap, software interrupt, whatever), reads it from a buffer which has been filled by the interrupt handler. See Figure 12.4. Similarly for writing; see Figure 12.5. The interaction of the application program called BIOS routines and the interrupt handlers is shown in Figures 12.3, 12.5, 12.9, and 12.10.
- Section 12.3
  When multiple devices can interrupt the CPU the following issues arise: selective masking, device identification, prioritization of the interrupts, and dispatching. Various schemes are discussed on how to handle these things based on the sophistication of the hardware involved.
- Section 12.4
  To unload some of the burden of doing the actual I/O, a DMA controller can be intialized to carry out the byte-by-byte I/O transfer. See Figure 12.17.

Last updated 12/22/99

360 syllabus