CS G180/CS5620 (Computer Architecture)

At this time, there are three primary links (below) to be aware of. Please use them as needed.

• Course directory (including homeworks, etc.)
• Resources web page (useful materials for doing the assignments)
• Help directory (especially with materials on basic use of gdb debugger and advanced use of gdb)

The computer architecture course is being offered this Fall, 2009. In this fast-moving field, traditional textbooks quickly fall out of date. In lieu of a textbook, we will heavily use resources from the web.

A related course (COM 3200, same title) was last taught six years ago under the quarter system. Its course number was re-assigned to CS G180, but it was never taught under that course number. More recently, its course number was re-assigned to CS5620. The course is now being taught in the year 2009, but the course must first be changed from the CCIS quarter system to the CCIS semester system. Since the course has to be re-designed to fit the longer semester timeframe anyway, I am using this opportunity to completely re-design the course. While the course is targeted at M.S. students, it should also be of interest both to advanced undergraduates, and to PhD students interested in systems issues. The course will include some leading edge material, much of which is not in textbooks.

Computer Architecture would be a very dry course without a goal. For better or worse, we are now fully in the middle of two revolutions that have occurred since the last time the course was taught:

1. The traditional Moore's Law is breaking down. CPUs no longer double in speed every two years. Legacy software will never run any faster than it does today. Buying a new computer will not help.

   To adapt, computer architects are building new architectures. The new architecturs are inherently parallel. They go under names such as: multi-core, many-core, GPGPU, Larrabee (an Intel chip intermediate betwen multi-core and GPGPU).

2. Computer security has now been widely breached through gaping weaknesses in the current computer architectures. To take one example, a single botnet is in control of two million PCs in homes and businesses, and being run by six individuals in other countries. (Dark Reading, April 22, 2009). This is just one example among others.

The prerequisites for the course are a knowledge of C (or of the core Java language, plus pointers), and a good level of sophistication. If you want to test yourself to determine your sophistication, look at a new system call that you have never seen before, such as mmap, and see if you can use mmap in a small program just by reading "man mmap" and information on the Web. If you can do this, you have the right level of sophistication.

There will not be a textbook. But there will be a rich set of supplementary online materials to describe the newer technologies, since these are not yet in textbooks.

Assignmnents and Grades: There will be homeworks and a mid-term during the first half of the course. The second half of the course will consist of individual projects or projects in small teams (at the choice of the student). The grade weighting will be based on: Mid-term: 30%, Homework: 30%, Project: 40%.

The course will include a brief traditional overview of the CPU layout (how binary code really gets executed in hardware) and an even briefer review of the cache, followed by a deep look at the new hardware architectures, and the corresponding software glue to make it all play together.

Some of the topics that have become required for anyone currently interested in computer architecture are:

1.  Many-core computing:
	The number of cores per CPU is currently doubling every
	two years.  Intel has promised an 80-core CPU by 2011.
	Most of our current software is completely unprepared
	to take advantage of such an architecture.  Also, such highly
	scalable chips will bring significant delays even in
	communication between cores.  How will we ever manage?
4.  GPGPU (General Purpose GPU computing):
	The video boards are becoming increasingly sophisticated, to the
	point where they look like entire computer clusters on a single board.
	Some people think that in the future, the market will split:
	1) An entire CPU/video board combination on a single chip:
	    For example, see the Larrabee as pre-announced by Intel a year ago:
		http://www.intel.com/pressroom/archive/releases/20080804fact.htm?cid=cim:ggl|larrabee_us_brand_t|kEB2B|s
		http://en.wikipedia.org/wiki/Larrabee_(GPU)
		(First products are likely to include multiple Larrabee's
		 on a video board.)
	2) A parallel co-processor (programmable in C) on a video board:
	    For example, see the NVIDIA CUDA arcthitecture, available
	      for two years:
	        http://en.wikipedia.org/wiki/CUDA
3.  The software glue to bring everything together:
	1) ELF linker/loader (standard linker for Linux):
	    http://en.wikipedia.org/wiki/Executable_and_Linkable_Format
	2) Shared dynamic library architectures (.so in Linux, .dll in Windows):
	    Recall the phrase "dll hell".
	3) Analysis tools:  ldd, nm, objdump,
		 'man ld.so', LD_DEBUG environment var
4.  Software instrumentation to manage the complexity:
	strace, valgrind, dtrace, systemtap, LTTng
5.  Security issues for current hardware/operating systems.
6.  According to interest of class:
 6.a.  DMTCP checkpoint-restart:
	architectural issues in saving a process to disk and later re-starting
	a lookalike process.
 6.b.  Virtual machines:  architectural issues and applications to security

The course will also include a moderate amount of writing code to explore the above concepts. Although the code will be moderately sized in number of lines of code, the conceptual understanding needed to write each line of code will be quite high. This is characteristic of system code at its best.