Advanced Computer Architecture -- CS 350c -- Syllabus

In this class, we will discuss how computers are organized and how primitive building blocks can be used to create a computing system. We will inspect a subset of the X86 instruction-set architecture and we will investigate how to program at the assembler level. We will introduce students to modern microprocessor memory hierarchy and other aspects of contemporary computing systems. Student participation and interest can influence the topics discussed and the assignments given, so feel free to suggest items of interest to you. The point of this course is to build up awareness of computer organization so the interested student is ready to pursue more advanced computer-architecture topics and to be a much better user and programmer of computers.

We will often refer to your CS429/CS439 textbook ("Computer Systems, A Programmer's Perspective" by Randal E. Bryant and David O'Hallaron, Prentice Hall). In fact, using a simulator, we will implement the pipelined implementation of the Y86 processor architecture presented in chapter 4 of "Computer Systems, A Programmer's Perspective." We will study sections from the Intel programmer's manuals. We will make use of other Web-based material.

Tests and quizzes are open-book, open-notes affairs -- however, no electronic devices (laptops, cell phones, tablets, PDAs, calculators) of any kind are allowed during test and quiz events. As such, you may wish to have a physical copy of any materials that you believe will be helpful during quizzes and exams. Remember, cell phones are not allowed during exams; during exams the remaining time will be periodically announced.

Our office hours are listed on the main class web-page. In addition, if you need help, you may certainly seek out and visit with the class TA and/or me. You may arrange to meet us at other times than those listed, but you will need to send E-mail to arrange a time. If we become too busy during office hours, we will expand our office hours to meet the needs of the students. This course asks students to model architectural features using both the C-programming language and a Lisp-based simulator that we will provide, so a clear understanding of what is being modeled as well as some programming skills are required.

This class will be taught in an "inverted" style. That is, we will concentrate class time on examples, working through code, understanding architectural features by discussing examples, writing a simple ISA-level simulator, and modifying a block-level model of our ISA-level computer. There will be short lectures to introduce various topics, but primarily, we will use class time for problem solving and exchanging information.

We will program in C. It is recommended that you have access to "The C Programming Language", second edition, by Brian Kernighan and Dennis Ritchie, Prentice Hall Software Series. For examples and help with C-language use, you will find that there are many Web pages devoted to C-language programming. Why C, or its extension, C++? It is the language that is used to implement many systems, such as FreeBSD, Linux, MacOS, Windows, as well as many user tools (e.g., grep, ed, sed, emacs,...). Java programmers should have no problem with the subset of C that we will use, but Java programmers will not be used to interfacing with assembly language programs. Student will be introduced to some C-language capabilities, such as referencing x86 processor-specific counters, that lie outside of the C-language.

Our gate-level circuit simulator is written in Lisp (ACL2). Why? I use ACL2 for circuit analysis, and I will show several examples of using logic to verify hardware circuit models. Although students will not need to write Lisp programs, our gate-level models will be written in a Lisp syntax. So, we will learn the rudiments of Lisp -- one of the oldest programming languages. Learning about simulation may be one of the enduring lessons from this course.

In some cases, it may be helpful to reference documentation about the x86 architecture. We have placed some reference material in the documents directory. In some cases, students may be asked to read small sections from these documents. Note that these documents are large -- these documents are indicative of the complexity of the x86 architecture and, in general, of modern computer systems. Other companies (AMD and VIA) than Intel that develop and market x86 processors must fully comprehend the information contained in these documents; unfortunately, the information contained in these documents is insufficient to develop a competitive x86 processor implementation. AMD offers their own manuals, which can be a place to look if the Intel documentation isn't sufficient. VIA doesn't publish any specification for their X86 implementations. Note, there are many undocumented features (e.g., caching read-ahead strategies, I/O ordering behavior, virtualization context switch mechanisms, et. al.) that are necessary to make a x86 processor perform well on a litany of common benchmarks, and for a x86 processor to be competitive, it will need to contain these features. Many x86 implementation mechanisms are protected by patents, and we are now free to build our own 32-bit x86 implementation using Intel's patents as all of Intel's patents specific to the Pentium have expired.

Tablet computers (e.g., the Apple iPad) also have complex architectures, and although quite valid for study, we will not explore tablet-based computers unless they contain a x86 processor.

For the adventurous student, special projects are possible. Such a project would replace laboratories 2 and 3, and such a project must be proposed by a student and approved by the instructor. This content of this kind of project is pretty flexible -- so long as it has to do with architecture. For instance, I am interested in the development of an ISA model of IBM's Harvest computer, which was a extension of IBM's Stretch computer. Another possible specification project might involve some older microprocessor, e.g., the Motorola 68030 or the National Semiconductor NS32032. Another project I'm looking for help with concerns booting FreeBSD or Linux on our evolving ACL2-based x86 ISA emulator. Other independent study projects are possible; please discuss these with the instructor.

The value you get from this class will be directly related to the effort you (the student) put forward. This class will require that you learn to work on your own, and this class may be less structured than many of the classes you have taken. For instance, I have taught CS429 many times, and when serving as an instructor for CS429, I lecture for many hours. In this class, there will be some lectures, but not as many nor as long as is typical in CS429. The remainder of class time will be used to directly address problems and seek their solutions. If you have a laptop computer, it will be very helpful for you to bring it to class -- this is not a requirement, but it's helpful for students to be able to individually access information as needed, and when we are discussing programming issues it may be helpful for you to immediately try it yourself.

Students will be encouraged to give short (five- to ten-minutes) presentations in class on particular topics. When well done, these presentations can serve in place of a missed quiz or homework. In fact, any student may be called upon to give a two- or three-minute presentation on something being discussed in class or on their solution to a homework problem. Please come to class prepared to work; we will sometimes stop for a few minutes to make sure that everyone that has a chance to consolidate their thinking and to help students overcome problems with their understanding or with questions about the in-class presentations.

The following gives an outline of what we will discuss. We are open to discussing other architecture topics of general interest, and we will include some of our own microprocessor design experience. The syllabus below is approximate; the exact rate at which we will cover some material will vary. Additional summary information about the class laboratories is available on the class laboratory and homework page.

  Schedule Below is Approximate, Lectures Dates May Change Slightly

  *** NOTE:  Test dates are tentative until January 21, 2016  ***
  *** NOTE:  Laboratory due dates are tentative until assigned ***

00     Jan 17  Course Introduction
01     Jan 19  C and Assembler programming, Laboratory 0 assigned

02     Jan 24  X86 Memory System, Memory Mountain
03     Jan 26  Development Tools, Subroutine Calling Conventions

04     Jan 31  Memory Hierarchy, Pointer Chasing
05     Feb  2  Laboratory 1 assigned, Laboratory 0 due

06     Feb  7  X86 Memory Management System
07     Feb  9  DRAM Memory Technology, caches

08     Feb 14  A Y86 Specification
09     Feb 16  Writing code for the Y86, Exam review

10  *  Feb 21  In-class Exam
11     Feb 23  Review of the Y86, Laboratory 1 due

12     Feb 28  Y86 Assembler
13     Mar  2  Y86 Assembler

14     Mar  7  Y86 Simulator
15     Mar  9  Y86 Simulator

       Mar 14  Spring Break
       Mar 16  Spring Break

16     Mar 21  Combinational Logic
17     Mar 23  Sequential Logic

18     Mar 28  Logic Validation and Verification
19     Mar 30  Logic-level Circuit Simulation, Class Simulator

20     Apr  4  Exam Review, Laboratory 2 due
21  *  Apr  6  In-class Exam

22     Apr 11  Sequential Logic, The ALU
23     Apr 13  Simulation, Laboratory 3 assigned

24     Apr 18  Simulation
25     Apr 20  The Y86 Pipeline

26     Apr 25  Pipeline Control Logic
27     Apr 27  Pipelining the Y86

28     May  2  Simulating the Y86 Design, Laboratory 3 due
29     May  4  Course Summary, Stump the Professor

       May  8  7:00 pm, Possible/Optional Review Session

    *  May 16, Final Exam, 9:00 -- 12:00 noon

  Schedule Above is Approximate, When Content Is Given May Change Slightly

There will be two, in-class (70 to 80 minute) examinations. See the class syllabus (marked with a "*" above) for the dates. There will be a number of unannounced "pop quizzes". There will be a final (150 minute) exam. On most weeks, homework will be assigned on Tuesdays and due nine days later (on Thursdays) by class time; no homework will be assigned the last week of class, but there may be a homework due the last week of class. There will be ten or so homework assignments given during the semester.

The weighting of the grades for the various aspects of the course are: two in-class exams - 24% (each 12%), quizzes 6%, final exam - 20%, homework - 15%, and class projects - 35%. The two lowest homework grades will be dropped in the computation of the final homework grade; homework is not accepted late. The lowest quiz grade will be dropped, and pop quizzes must be taken when given. Projects may be turned in one week late, but no later than the last day of class; late project submissions suffer a 20% reduction of the grade given for the content of the project. Examinations and quizzes must be taken at the scheduled times.

The weighting for the laboratory assignments will be as follows:

  Laboratory   Percentage of Course Grade
  Lab 0:           5%
  Lab 1:          10%
  Lab 2:          10%
  Lab 3:          10%

Note, the laboratory assignments are important; performing the work necessary to complete the laboratories is means by which you will solidify your understanding of architecture and the work that it takes to be a computer architect. Once a laboratory turn-in date has arrived, material addressed in that laboratory may appear on an exam.

The grading for the entire course will be as follows:

    Course Score    Grade
     [90 -- 100]      A
     [87 --  90)      A-
     [85 --  87)      B+
     [80 --  85)      B
     [77 --  80)      B-
     [75 --  77)      C+
     [70 --  75)      C
     [67 --  70)      C-
     [65 --  67)      D+
     [60 --  65)      D
     [ 0 --  60)      F
Note the interval marks around the course-score column. For example, a course grade of B will be assigned if your semester grade is greater than or equal to 80 and less than 85. This also means that a course grade of at least 67 needs to be achieved for this course to count toward a UTCS degree.

The final exam will be given at the time as provided, set by the UT Registrar. Note, the exact time for the final exams is published by the UT Registrar about a month before the end of the semester, and given our class meeting time there is and expected time and date for our final exam. Each time I teach a course, I am told by a student that he/she needs to take the exam early because of an existing airline reservation. Please make sure that your post-semester travel plans start after the final exam. If you need to leave Austin prior to the final exam date, then this may not be the course for you.

The students that do well in this class are survivors. This class is a lot of work, and it is important to keep current. The material in this class is cumulative; it can be quite difficult to catch up if one falls behind. It is important to keep turning in homework; homework grades are our most reliable indicator of how well a student will do in this class. Note, it is important to show up for class, as pop quizzes are given, and material not reproduced in any particular book or web page may be discussed.

Return to CS350c course homepage.