581305-6 Computer Organization I, (4 cr, 2 sw)

Position in Curriculum

Undergraduate course in Computer Science. Obligatory for intermediate studies for those majoring in CS, elective for basic studies in CS.

Course Prerequisites

Basic ideas in programming which are introduced in (e.g.) Introduction to Programming class.

Goal

Understand salient features of a Computer System from the executing program viewpoint: what are the computer system components and how they execute a given program. The emphasis is on the execution of one program at the (symbolic) assembly language level.

The assembly language level operation of a processor is viewed both in general as well as in operational level using a simple example machine (ttk-91), its (symbolic) assembly language, and simulator that runs assembly language programs developed for that machine. We also look at the operating system role in the program execution.

Learning objectives according to ACM/IEEE Computing Curricula 2001

Architecture and Organization (AR)

The computer lies at the heart of computing. Without it most of the computing disciplines today would be a branch of theoretical mathematics. To be a professional in any field of computing today, one should not regard the computer as just a black box that executes programs by magic. All students of computing should acquire some understanding and appreciation of a computer system's functional components, their characteristics, their performance, and their interactions. There are practical implications as well. Students need to understand computer architecture in order to structure a program so that it runs more efficiently on a real machine. In selecting a system to use, they should to able to understand the tradeoff among various components, such as CPU clock speed vs. memory size.

The learning outcomes specified for these topics correspond primarily to the core and are intended to support programs that elect to require only the minimum 36 hours of computer architecture of their students. For programs that want to teach more than the minimum, the same topics (AR1-AR7) can be treated at a more advanced level by implementing a two-course sequence. For programs that want to cover the elective topics, those topics can be introduced within a two-course sequence and/or be treated in a more comprehesive way in a third course.

AR2. Machine level representation of data [core]

• Explain the reasons for using different formats to represent numerical data.
• Explain how negative integers are stored in sign-magnitude and twos-complement representation.
• Convert numerical data from one format to another.
• Discuss how fixed-length number representations affect accuracy and precision.
• Describe the internal representation of nonnumeric data.
• Describe the internal representation of characters, strings, records, and arrays.

AR3. Assembly level machine organization [core]

• Explain the organization of the classical von Neumann machine and its major functional units.
• Explain how an instruction is executed in a classical von Neumann machine.
• Summarize how instructions are represented at both the machine level and in the context of a symbolic assembler.
• Explain different instruction formats, such as addresses per instruction and variable length vs. fixed length formats.
• Write simple assembly language program segments.
• Demonstrate how fundamental high-level programming constructs are implemented at the machine-language level.
• Explain how subroutine calls are handled at the assembly level.
• Explain the basic concepts of interrupts and I/O operations.

AR4. Memory system organization and architecture [core]

• Identify the main types of memory technology.
• Explain the effect of memory latency on running time.
• Explain the use of memory hierarchy to reduce the effective memory latency.
• Describe the principles of memory management.
• Describe the role of cache and virtual memory.

AR5. Interfacing and communication [core]

• Explain how interrupts are used to implement I/O control and data transfers.
• Describe data access from a magnetic disk drive.

Programming Languages (PL)

A programming language is a programmer's principal interface with the computer. More than just knowing how to program in a single language, programmers need to understand the different styles of programming promoted by different languages. In their professional life, they will be working with many different languages and styles at once, and will encounter many different languages over the course of their careers. Understanding the variety of programming languages and the design tradeoffs between the different programming paradigms makes it much easier to master new languages quickly. Understanding the pragmatic aspects of programming languages also requires a basic knowledge of programming language translation and runtime features such as storage allocation.

PL2. Virtual machines [core]

• Describe the importance and power of abstraction in the context of virtual machines.
• Explain the benefits of intermediate languages in the compilation process.
• Evaluate the tradeoffs in performance vs. portability.
• Explain how executable programs can breach computer system security by accessing disk files and memory.

• Compare and contrast compiled and interpreted execution models, outlining the relative merits of each.
• Describe the phases of program translation from source code to executable code and the files produced by these phases.
• Explain the differences between machine-dependent and machine-independent translation and where these differences are evident in the translation process.
  

Methods for Achieving Credit

The course can be taken either as a conventional lecture course, study circle course or as a final exam. The course is lectured (at least) every Spring (and also in the Summer by Open University). Please notice that the term exam for the lecture course can not be used as a final exam. All exams can be taken in English, but you need to confirm this with the instructor one week before the exam.

Lecture Course

The conventional lecture course involves

• lectures 4h/week for 6 weeks (only in Finnish, sorry)
• practice sessions 2h/week for 6 weeks (possibly one group in English)
• course exam (in English when needed, confirm with the instructor)

The study circle course involves

• lectures 4h (only in Finnish, sorry)
• independent study from text book
• practice problems, dicussion problems and projects done independently or with study group
• guided practice sessions 2h/week for 6 weeks
• course exam (in English when needed, confirm with the instructor)

If you do not understand Finnish but you still want to take the lecture course without attending the lectures, you will have significant amount of independent study to do.

You should acquire a text book for you, and you should read it in a relatively good pace to keep up with the lecture course. You should also do most of the homeworks for each problem set (including the first one!), and attend the practice sessions, where you can ask questions to clarify the topics of that day. If you start studying only after the attending the first practice session, you are already very late and you will have trouble catching up.

Course Material

Lecture course:

• Lectures and lecture notes
• Auvo Häkkinen, Tietokoneen toiminta, opetusmoniste D390, Dept of CS, Univ. of Helsinki, 30.1.1998.
  (Chapters 1-6, 8-11)
  Instead of these lecture notes in Finnish, you can use the course material given for Final exam.
• Auvo Häkkinen, KOKSI simulator.

Final exam:

• William Stallings, Computer Organization and Architecture, 7th Ed., Prentice Hall, 2006.
  Chapters 1-2, 3-3.1, 4.1, 5-5.2, 6-6.1, 7-7.5, 8-8.2, 9-9.2, 9.4, 10, 11.1, 12.1-3
  
  or William Stallings, Computer Organization and Architecture, 6th Ed., Prentice Hall, 2003.
  Chapters 1-2, 3-3.1, 4.1, 5-5.2, 6-6.1, 7-7.5, 8-8.2, 9-9.2, 9.4, 10, 11.1, 12.1-3
  
   
• Andrew S. Tanenbaum, Structured Computer Organization, 5th Ed, Prentice-Hall, 2006.
  Chapters 4.2, 5-5.1.4, 7.3-7.4
  
  Andrew S. Tanenbaum, Structured Computer Organization, 4th Ed, Prentice-Hall, 1999.
  Chapters 4.2, 5-5.1.4, 7.3-7.4
  
• Auvo Häkkinen, Tietokoneen toiminta, opetusmoniste D390, Dept of CS, Univ. of Helsinki, 30.1.1998, in Finnish.
  Chapters 4-5, I.e., example computer ttk-91.
  You must understand the basic ideas of assembly language programming. It is sufficient to be able to design and implement little programs and subroutines with the ttk-91 symbolic assembly language (see KOKSI simulator.)
  
  You can also study ttk-91 architecture from the TITOKONE simulator and its user's manual.
  
  However, you can use any symbolic assembly language for any (well known) real or hypothetical machine, if you so wish. Confirm any other than ttk-91 assembly language with the instructor before the exam.
  
• Always check the exam area for a final exams short time before the examination.

Contents

• Overall Computer System
• TTK-91 computer and KOKSI simulator
• Pregram representation in system and assembly language programming
• CPU and bus basic structure, processor states
• Data representation and error correction codes
• Internal and external memory
• I/O implementation and I/O devices
• Implementing and executing programs in the system, process and its states
• Execution of Java programs