This study guide provides the objectives, requirements, and timetable for this course.

Contact Information.

Introduction

Computer Science has been described as the ``mechanization of abstraction''. At the physical level computers are electronic machines that understand just two signals, a high voltage and a low voltage. We call the high voltage ``1'' and the low voltage ``0''. Thus computers are machines that perform simple computations such as arithmetic and logic operations on 1's and 0's. Every computer understands a number of instructions that are encoded as 1Ős and 0Ős and uses data that is encoded in 1's and 0's. Since it is very difficult to program using just 1's and 0's, higher level languages have been invented that are translated into 1's and 0's.

Languages such as Pascal, Scheme, and C++ enable the use of abstract instructions to create sophisticated programs. Yet every program written in one of these languages must be translated into 1's and 0's before it can be executed on a computer.

Every program that is written,then, regardless of the language and the level, must eventually be turned into machine language. This means that the abstractions that appear in higher level languages are directly related to real physical components in a machine. Thus to develop robust and efficient programs, it is essential to understand how your code will eventually be used.

This is easily evident in software that is "close to the metal", i.e. any program that contains assembly language code or that is written in C or C++. Examples include the obvious, operating systems (DOS, UNIX, OS/2, System 7, etc.) and compilers. It also includes many application programs like spreadsheets, word processors, statistical packages, etc. In all of this software, some assembly language is used, much C is used, and many machine dependencies exist.

The goal of this course is to study computer architecture. To make this study concrete, we will study RISC organizations and the MIPS architecture in particular. The course begins with a study of logic circuits. We will then discuss all aspects of a computer including memory, the CPU (control and arithmetic), buses and I/O organizations.

The objective is to understand as many architectural aspects of computers as possible.

We will work mostly at the digital logic level. Though many issues at this level are determined by lower level concepts, we do not have the time nor the need to understand the lower level concepts. Several excellent courese are offered by the physics department that cover architecture at the device level. The intension of this course is to work on abstraction levels from digital logic up to assembly language. The emphaises will be on the hardware/software interface. Thus we will examine pipelining in some detail since this is an issue that every compiler for RISC or RISC like machines (including the Pentium) must address.

Finally, we will consider parallel machines. Even though microprocessor speed increases dramatically every year, it is not increasing fast enough to satisfy the needs of modern complex software. Thus alternative architectures, especially parallel architectures, are becoming necessary and practical. We will consider some of the approaches and constraints to this approach.

You will not be an expert at either instruction set design or computer architecture at the end of the course, but you will have a good understanding of general issues and their effect on programming languages.

Warning. This is a difficult course. There are a myrid of intricate details that must be mastered. Though each detail is in itself easily grasped, the sum of details can be staggering and you will spend a lot of time on the computer completing assignments.

Required Textbooks.

Computer Organization and Design, the Hardware/Software interface, 3rd ed. David A. Patterson and John L. Hennessy, Morgan Kaufmann Publishers, San Mateo, CA., 2005. This book contains the conceptual information. It will be used as the primary reference for the classroom discussions.

Communication

• Class lectures will not exactly follow the texts. You are expected to attend all classes and attendence will be taken.

• You are accountable for all material covered, all announcements made, and all handouts given out during class.

• Ways to reach me:

  • . Come during office hours!!!

  • Send electronic mail to barr@ithaca.edu
    

  • . Leave a note (including your name, schedule, phone number and userid) either under my door or in my mailbox in the Math/Computer Science Department Office 2nd floor Muller).

Grading

Grading will be based on the following events:

Problem Sets (weekly; 10-12 total; each 10 pts) 16%

Exams (2 exams, 1 final; each 100pts) 40%. Exams will take place in class on Tuesday, 22 February and Tuesday, 29 March. The final will be at 1:30 on Monday, 2 May.

Projects (2 total; 100pts each) 27%.

Paper or Final Project (1; 100pts) 13%.

Class Participation 4%.

Assignments

1. Class attendance is mandatory. You are responsible for all material and announcements given in class. If you miss a class you are responsible for obtaining the missed material/announcements. Missing 4 classes will result in a half letter drop in your final grade, e.g., an A will become an A-. If you miss more than 8 classes I will withdraw you from the course.

2. All assignments other are expected to be INDIVIDUAL work except for the projects which will be done in pairs. Thus problem sets and exams must be completed individually. All work handed in must be original. Duplicate or very similar assignments receive negative grades. Flagrant cheating (on an exam or project, or on laboratories) will result in (at minimum) a FAILING GRADE for the course. General discussion is allowed, but not sharing of answers, algorithms, or scripts.

3. SAVE your intermediate work until an assignment has been graded, returned, and recorded. KEEP backup copies of the final versions of your labs and projects. Also, keep the source code of your stacks on your disk, without editing them. NEVER leave program listings lying around or throw them away in public areas.

4. Assignments are to be turned in either before or after class or put under my office door. Projects will be placed in the class directory according to the instructions given in the project description.

5. Graded assignments will be returned in class. Work unclaimed in class may be picked up later from outside my office. If you have a question on a grade, bring it to my attention within one week of the assignment's return.

6. Periodically, I will electronically post grades as we have them recorded. It is your responsibility to check these listings to ensure their correctness, within one week of the posting.

7. Handwritten assignments should be neat and easy to read (Or else type them!). Include your name and section number on every page and in every stack.

8. It is more productive to use the computer for entering, editing, and running scripts, and then spend time AWAY from the machine debugging a script.

9. Every program must contain a comment giving your name, section and the assignment number. This introductory comment should briefly describe the purpose of the program, describe how it is implemented, given the major interface elements, etc.

10. A late assignment will have 33% of the points deducted from the grade if it is turned in within 24 hours after the due time, 67% deducted if within 48 hours. After 48 hours an assignment will be marked but no credit will be given. Always turn in whatever work is done at the due time. You should have something FINISHED (i.e., functioning and commented), even if the entire assignment isn't completed. Individual exceptions should be discussed with me in advance.

11. Don't get behind in this class! Start each assignment as soon as it is handed out, so that you have time to ask questions and can use your time wisely.

Return to John Barr's Home Page

Last updated on 17 Jan 2005 by John Barr