22C:40 Draft Specification

22c:26 Assembly Language and Computer Architecture

Note on course numbering

The number 22C:40 would be useful, in the current numbering system, for an upper level elective on digital hardware. That course should focus on the road from logic gates to processors, with digressions down to the physical device level. In fact, as an upper level elective, this should really be numbered at the 100 level, and it should be cross-listed with ECE and developed in close cooperation with them.

I suggest the numbering 26 to suggest that, like 22C:34, this course can be taken at around the same time that a student takes 22C:30. There is nothing really compelling about this numbering, however.

Objectives

To develop an understanding of the relationship between programming and the machines we use to execute programs. This includes an understanding of the essential features of those machines, with detailed focus on one example, plus an understanding of the translation process from source language to machine language, an understanding of the classical fetch execute model for execution of programs, and an understanding of the basic ideas underlying the implementation of processors that implement this cycle.

The example architecture used in this course should be relatively simple! Classic architectures such as the IBM System 360 may make better examples than the far more complex Motorola 68000, VAX or Pentium architectures because the latter contain such large numbers of addressing modes and instruction formats. Some of the simpler RISC architectures of the 1980's would also make good examples. Ideally, the assembly language used should support separate assembly and linkage, and it should support classic features such as macro and conditional assembly.

Students coming out of this course should be able to hand translate all of the classic control structures and data structures of high level languages, including object oriented languages, into an example assembly language, and they should be able to translate individual instructions and small programs from that assembly language to machine language. They should understand that the translation of high-level constructs to assembly and machine language frequently involves alternative equivalent instruction sequences, and they should understand the problem of optimal translation in terms of choices between these sequences.

A central goal of this course is to finish building the student's understanding of the difference between the concrete representation of an abstraction and its implementation. At the assembly language level, all data objects are represented by bit patterns that are entirely free of any inherent interpretation, and it is only by writing code that imposes an interpretation that these bit patterns take on the behaviors of the desired abstraction. The central illustrations of this, for the purpose of this course, will be simple numeric types such as integers and floating point numbers.

Coverage of computer architecture in this course is primarily at the register-transfer and processor-memory-switch levels of abstraction. Students will learn about busses, caches and similar components, and they will learn about the data flow within the processor. Students will be exposed to gate-level logic design, but this will be supplementary material to help explain why the instruction set is designed the way it is, with a very limited set of arithmetic and logic operators selected on the basis of ease of implementation.

Prerequisites

Computer Science II -- Students entering this course should have a firm understanding not only of small programs but of programming in the large and the use of interesting libraries. They should have seen control structures as diverse as case-selection and recursion, and they should have some exposure to linked data structures, although not much.

Discrete Structures -- It is not clear whether this course needs discrete structures as a prerequisite. Does it?

Major topics:

10% A) Data Representation

• Binary, octal and hexadecimal.
• One's and two's complement, signed magnitude and biased representations.
• Character codes, particularly ASCII.
• Floating point numbers.
• Arrays, records and pointers.

10% B) Computation

• Binary arithmetic.
• Logical operations.
• Floating point operations.

30% C) Architecture

• CPU, registers and memory
• The fetch execute cycle
• Data movement instructions
• Arithmetic instructions
• Conditional branches
• Subroutine calls
• Addressing modes

30% D) High level constructs

• Iteration
• Selection
• The case statement
• Arrays, records and objects
• Calling sequences
• Activation records
• Elementary storage allocation

10% E) Advanced Material

• Support libraries
• Macro assemblers
• Compilation techniques
• Input-output hardware
• Interrupts
• Memory management hardware
• Digital logic

Programming assignments

Five or six programming assignments plus programming snippets in homework assignments. The first programming assignment is typically a "hello world" assignment, but after that, assignments typically focus on issues of data and control structure, including at least one recursive subroutine.