CSCI 463: Computer Architecture and Systems Organization
Fall 2022

Course Information

Organization and use of computer systems. Basic concepts and examples from microcomputers and networks, peripheral components, data communications, and the relationship between hardware components and the operating system.

Course Syllabus

Contact Information and Office Hours

Instructor

John Winans (You can contact me via Linked In)

Office Hours:

Tuesdays & Thursdays 8:45am - 10:45am & 12:30pm - 1:30pm

and by appointment

Tentative Schedule

Assignments

All assignments are due at, or before, 23:59:59 in US/Central time on the dates specified. The timestamp of the assignment submission shall be used to determine when you handed it in.

• Assignment 1 (10 points pass/fail) Due: 2022-08-26
• Assignment 2 (10 points) Floating Point Numbers, Due: 2022-09-09
• Assignment 3 - Memory Simulator (20 points) Due: 2022-09-23
• Sample main.cpp code from handout
• Some sample test files
• A video discussing ctype.h (functions like isprint())
• Assignment 4 - RV32I Disassembler (20 points) Due: 2022-10-07
• Assignment 5 - RV32I Simulator (30 points) Due: 2022-11-04
• Assignment 6 - std::thread (10 points) Due: 2022-11-18
• Assignment 7 - TCP Sockets (10 points) Due: 2022-12-02 (THIS DUE DATE IS FIRM, NO EXTENSIONS ARE ALLOWED)

Course Information

• How to hand in your homework assignments.
• Never use evil filenames.
• Documentation Standards.
• How to install and use PuTTY and FileZilla to access the departmental Linux servers.
• How to use Linux/Unix to manage your homework assignment projects.
• Help for Students Using Blackboard.

DANGER WILL ROBINSON! Developing and testing your assignments on your own PC is encouraged. However, your grade is based solely on our ability to build and run your program on hopper.cs.niu.edu as described in the assignment handouts! Therefore, it does not matter if it runs OK on your own system. A program that fails to build or run on hopper.cs.niu.edu will be graded as such.

You must test your program on hopper.cs.niu.edu before handing it in.

[On Windows, you can install WSL & Ubuntu and then use one of its terminal windows to do development and testing of Linux code on a Windows PC.]

But... you must still test your program on hopper.cs.niu.edu before handing it in.

C++ Stuff You Should Know (Review)

• How things are stored in memory:
• How to use stdint.h (The first half is most relevant here. The second half is useful for debugging numeric overflow problems.)
• The sizeof() operator
• How arrays are stored in memory
• Where things are stored in memory:
• An Intro to Stacks & Stack Operations
• How a process manages its memory/address space
• Stack frames (aka activation records) and gdb
• Pointers (part 1)
• Pointers (part 2)
• Pointers (part 3)
• Characters & ctype.h
• C Strings
• References
• Classes

Reading, Printing, and Formatting Numbers in C++ (Review)

Bonus!! Some reviews for those that forgot how to do this!

Lectures:

• Reading Data From std::cin (Review)
• Writing and Formatting Data to std::cout (Review)
• A C++ Build Process Overview (Review)

Some Useful C++ Standard Library References

• References for the C standard library, the C++ IO stream libraries, and the C++ string class
• References for the standard library container classes, C++ strings, C++ I/O, and many standard C library functions
• C++ and STL notes with some nice code examples

Lectures:

• A free-association on using the getopt(3) man-page example source code

Web Links:

• getopt(3) (The section 3 manual page for getopt)
• The GNU library doc for getopt(3)
• Getopt Wikipedia
• Getopt GeeksForGeeks
• Usage statements and what they mean

Common Compiler Issues (bonus lecture!)

Lectures:

• How to fix Signedness Errors/Warnings
• How to fix error: unused parameter 'x'

Design For Debugging (bonus lecture!)

Lectures:

• How to use assert(3) to protect your code from itself!
  The idea behind using assertions (and/or exceptions in C++) is to check arguments and variables in your code to make sure that they are not corrupted by errant code elsewhere in your application.

  Note that assert is for checking against program logic problems. NOT for checking user errors! Some times the difference can get blury. When in doubt, report a regular user error message and terminate your application gracefully. assert() will terminate your application ungracefully.

• How to use valgrind(1) to check for corrupted memory
  Valgrind is incredibly useful for verifying that a program has not corrupted its memory while it runs. This includes things like writing past the end of an array and forgetting to delete objects (that were previously created by calling new) when they are done being used.

  ALWAYS valgrind your homework as part of normal debugging and testing before handing it in.

A number of good resources are available with discussions of the topics discussed in this course. Here are some popular ones.

• From Nand to Tetris includes free copies of some of the best chapters in the companion text book The Elements of Computing Systems. These include Boolean Logic, Boolean Arithmetic, Sequential Logic, and Computer Architecture.
• Nandgame presents a system where you can connect NAND gates until you have a a recognizably running computer! It claims to have been inspired by From NAND to Tetris mentioned above as well as the book: Code: The Hidden Language of Computer Hardware and Software.

Introduction

Lectures:

• Introduction to CSCI 463 (Fall 2022)
• Bored? Speed Up Video Playback Speed!, use closed captioning, change the video quality, etc.
• How To Do Assignment 1

Computer History

Lectures:

• Computing Machinery History

Web Links:

• Computer History
• Turing Completeness
• Imperative Programming
• Declarative Programming
• Colossus & Bletchley Park (A video showing Colossus running)
• A Bletchley Park Tour (with a detailed look at the Enigma)

Boolean Algebra

Lectures:

• Boolean Algebra (part 1)
• Boolean Algebra (part 2)

Handouts:

• Boolean Algebra (as seen in lecture)

Web Links:

• George Boole
• Boolean Algebra (A wikipedia article discussing boolean algebra)
• Canonical Normal Form (aka SOP and POS)
• Saturation Arithmetic (related to the idea that AND and OR act like saturated multiplication and addition, respectively)

How to use Doxygen

Lectures:

• Documenting a C++ application with Doxygen
• Note that this lecture shows what Doxygen does with your code and comments so that you understand what is going on.
• For this course our concerns will be limited to that of creating the proper doc boxes so that Doxygen CAN be used... as shown the handouts below.
• Of course, you are encouraged to give running Doxygen a try. It should be installable on any Unix(ish) OS from standard packages. (On Windows, you can install WSL and then use it in one of its terminal windows.)

Handouts:

• An example of a properly documented function
• The Doxyfile.hacked file as seen in the above tutorial

Web Links:

• The Doxygen web site

Numeric Representation

Lectures:

• Counting In Binary
• Adding In Binary
• Two's Complement Signed Binary Integers
• Subtracting In Binary (includes a discussion on overflow and truncation)
• IEEE-754 Floating Point Number Representation

Handouts:

• RISC-V Assembley Language Programming (RVALP) (Click on the top release link and download the rvalp.pdf asset.)

Web Links:

• The IEEE-754 Official Standard
• What Every Computer Scientists Should Know About Floating Point Numbers
• IEEE-754 Wikipedia Page
• An article discussing the details and nuances of IEEE-754 numbers

Logic & Bitwise Operations

Lectures:

• Signed and unsigned binary number extension
• Logical & arithmetic shifting of binary numbers
• Memory dumps & endianness
• How to use stdint.h
• Don't get tricked by typedef!
• C/C++ Bitwise Operators

Web Links:

• Wikipedia endianness page
• A Computerphile video on endianness
• Wikipedia shifting and logical operations page

Combinational Circuits

Lectures (1):

• Combinational Circuits (part 1): Half Adders & Full Adders
• Combinational Circuits (part 2): Decoder, Demux, Mux, and ROM

Lectures (2):

• A closer look at adders & subtractors
• Arithmetic Logic Unit (ALU)

Schematic Handouts (1):

• The basic gates
• Demonstration of the completeness of the NAND function
• Cascading gates to make logic with more than two inputs
• Be careful when cascading gates that won't work!
• Single gates with more than two inputs
• 3-in 8-out decoder
• 1-in 4-out DEMUX
• 4-in 1-out MUX
• Half adder
• Full adder (built with a decoder in SOP form)
• Full adder (built with a reduced boolean algebra expression)

Schematic Handouts (2):

• Multi-bit adder
• Multi-bit subtractor
• Multifunction adder/subtractor
• An 8-bit ALU

Web Links:

• Decoder
• Multiplexer & Demultiplexer
• Half & Full Adders
• Moore's Law

Sequential Circuits & Memory

Lectures:

• The Sequential Circuits (part 1): The RS Latch
• Sequential Circuits (part 2): More RS Latches & D-Latches
• Static Memory (is just a bunch of D-Latches!)

Schematics & Other Handouts:

• Latches
• Timing Diagrams
• Memories

Web Links:

• Latches/Flip Flops
• Timing Diagrams
• Timing Diagrams
• D-Latches, Clocks & Timing Diagrams

Counters & Finite State Machines

Lectures:

• Counters (Sync & Async)
• Mealy & Moore Finite State Machines

Schematics & Other Handouts:

• Sync/Asynch Counters
• Finite State Machines (2024-05-03 New and improved!)

Web Links:

Note that there are more types of latches and flip-flops than I will discuss in this course. If you look around the web for more information you might find yourself confused if you run into those other types. Here are some links that discuss this subject using D-Latches:

• Asynch Counters
• Sync vs Asynch Differences
• A different perspective on the Mealy & Moore FSMs (including the same example I used in my lecture)

The Von Neumann Machine

• Buses and the Von Neumann & Harvard Architectures
• Computer Design (part 1)

Web Links:

I was always confused why the common term for the von Neumann machine was to refer to it as an architecture when the topic is actually referring to its organization.

The so-called von Neumann architecture might be easier to understand when discussed in the same context as an alternative approach that is referred to as the Harvard architecture.

• von Neumann architecture
• Harvard architecture (the other kind)

Addressing Modes

• Stacks (needed to understand the addressing modes)
• Addressing Modes (the 68k has a wide vareity of modes)

Handouts:

• Stack Examples (as seen in lecture)
• 68k Addressing Modes Examples (as seen in lecture)
• MC68030 User Manual (as seen in lecture)

RISC-V Architecture

Lectures:

• Introduction to RISC-V and the RV32I Instruction Set (Addressing Modes, The Instruction Cycle, Assembly Language)
• RV32I Instruction Encoding/Decoding (Machine Instruction Formats)

Handouts:

• RISC-V Assembley Language Programming (RVALP) (Click on the top release link and download the rvalp.pdf asset.)
• An RV32I Computer Schematic (for Computer Design parts 2 and 3)
• RV32I Computer Timing Diagrams (for Computer Design parts 2 and 3)

Address Spaces & Subroutine Calling Conventions

• An Introduction to Address Spaces (for typical C/C++ Programs)
• Stack Frames (and gdb)
• The RV32I Application Binary Interface (aka Subroutine Calling Conventions)

Writing Freestanding Programs for a RISC-V CPU

Lectures:

• RISC-V Pseudoinstructions (these make writing RS32I programs much easier!)
• Building Freestanding RISC-V Programs with the GNU toolchain.

Web Links:

• rvddt and example code as seen in lecture.
• Note: On hopper.cs.niu.edu the RISC-V compiler seen in lecture has been installed here:
  /home/research/riscv32/install/rv32i
  This means that you can download, build, and run the rvddt github project on hopper like this:
  • git clone https://github.com/johnwinans/rvddt.git
  • cd rvddt/src
  • make world
  • cd ../examples
  • Change the path to the compiler toolchain in the Make.rules file to this:
    GNU_DIR=/home/research/riscv32/install/rv32i
    
• For reference, there is a copy of the rvddt project with a 'fixed' Make.rules file on hopper here:
  /home/hopper/winans/csci463/rvddt
  
• You can use this compiler and rvddt example programs as templates to create your own RISC-V programs to test your own simulator.

Multiprocessors

Lectures:

• Multiprocessors/Multicores
• Flynn's Taxonomy

Web Links:

• Flynn's Taxonomy: SISD, SIMD, MISD, and MIMD (Wikipedia)
• Multithreading - For those interested in more details (Wikipedia)

Memory

Lectures:

• Virtual Memory (and page faults)
• Shared Memory
• Storage Systems and the memory hierarchy
• Cache Memory

Handouts:

• Storage Systems notes (as seen in lecture)
• Shared Memory, uniform & non-uniform access (Wikipedia)
• CPU cache (Wikipedia)
• Cache placement policies (Wikipedia)
• What Every Programmer Should Know About Memory
• Some notes about aspects that are getting out dated.
• Performance Analysis and Tuning on Modern CPUs

Threads & Synchronization

Lectures:

• Multithreaded Application Synchronization pt. I (Freestanding Startup & Synchronization a'la RISC-V)
• Multithreaded Application Synchronization pt. II (Mutual Exclusion Locks a'la RISC-V)
• C++ std::thread

Input/Output

Lectures:

• Shift Registers
• Memory-mapped I/O and the PCI Express bus

Web Links:

• Shift Registers (Wikipedia)
• Memory-mapped_I/O (Wikipedia)
• PCI Express (Wikipedia)
• UART (Universal asynchronous receiver-transmitter) (Wikipedia)
• AY-3-1015D Ye Olde UART Datasheet
• A close look at a model 15 teletype (Ye even MORE Olde serial device)
• A model 15 teletype connected to Linux

Interrupts

• How Interrupts & Traps Work

Web Links:

• The RISC-V specification and privileged instruction manuals
• The 6502 Datasheet (as seen in lecture)

Networks & IPC

Lectures:

• Introduction To Networks
• IPC (InterProcess Commuinication) Tutorial pt. 1
• IPC (InterProcess Commuinication) Tutorial pt. 2

Handouts:

Note: The IPC and Advanced IPC tutorials are shared below under the 4-Clause BSD copyright.

• 4.4BSD IPC Tutorial
• Makefile
• client.cc (updated version of figure 7a)
• server.cc (updated version of figure 7b)
• 4.4BSD Advanced IPC Tutorial

RAID (Redundant Array of Inexpensive Disks)

Lectures:

• RAID Basics

Web Links:

• The RAID Levels (Wikipedia page as seen in lecture)

Audio Files

Lectures:

• Audio FIles, Pulse Code Modulation, and MIDI

Handouts:

• snd.cpp (program source as seen in lecture)

Web Links:

• Sound (wikipedia)
• Pulse-code modulation (wikipedia)
• Au file format (wikipedia)
• CDDA (wikipedia)
• MIDI (wikipedia)
• Octave (wikipedia)
• Piano key frequencies (wikipedia)
• MIDI tuning standard (wikipedia)
• Envelope (wikipedia)
• Musical note (wikipedia)
• Natural Notes (wikipedia)