CSCI 8530 Advanced Operating Systems

Size: px

Start display at page:

Download "CSCI 8530 Advanced Operating Systems"

Georgiana Martin
5 years ago
Views:

1 CSCI 8530 Advanced Operating Systems Prof. Stanley Wileman Computer Science Department University of Nebraska at Omaha Last update: 1/10/2017

2 Introductions and Expectations

3 Confession Okay. The phrase Introductions and Expectations was stolen specifically from the ACM SIGOPS (Special Interest Group on Operating Systems) series on How To Write An Operating System. However, the notes made there on what is expected of a student are appropriate as well to students in this course. So to some extent take the following notes with a grain of salt. But keep in mind that the observations were made by folks presenting a course on operating systems to a much larger audience.

4 The Goal (Part 1) Writing an operating system is a bit harder than writing a conventional program, by its nature: you're actually writing the code that works the machine and runs other people s code. The lack of debuggers, libraries, and standard code makes it the black art that it has become. You can t debug using traditional methods because you're writing at a lower level than the debugger itself (even the debugger calls the operating system). Libraries are essentially nonexistent because each operating system treats the machine in a different manner and it would be extremely difficult to write the libraries for generalpurpose use.

5 The Goal (Part 2) In fact, the only thing we can really do is provide a structure for development and some example working code. This approximately summarizes what we ll be spending our time doing this semester. We ll be studying a real operating system at the code level to gain an understanding of what s really involved in an operating system.

6 Prerequisites (Part 1) Programming experience, preferably C or C++ Since systems programming is harder than conventional programming, it s assumed that if you want to write an operating system, you have at least some programming experience. Hopefully, you know either C or C++ fairly well. You should know pointers, structs and the basic data types, control loops, and the preprocessor well, but don t worry about the standard libraries, ANSI or otherwise, since those are essentially irrelevant in systems programming (you ll most likely have to write these yourself in the later stages).

7 Prerequisites (Part 2) Knowledge of the architecture - Knowing the assembly language and the architecture of the machine you re developing for is a definite bonus. If you don t know these already, you can pick them up along the way, but it makes development that much harder. SigOPS will be providing a structure for the i386, so if you plan on developing for the PC, you can learn as you go from some of our known good code.

8 Prerequisites (Part 3) A Machine - You need at least one machine that can be rebooted frequently for testing; preferably, you have another machine for editing and/or compiling. We will be using Intel Galileo (Gen 2) boards to test the operating system and your work, and a Linux system for development. Usage details are still being determined.

9 Prerequisites (Part 4) Persistence and Mental Stability - I once spent two weeks at work (where I was porting an operating system fulltime) trying to work out a bug that was fixed by changing one bit. Not only that, but all the documentation on the processor that I found was either lacking this critical piece of information or was very misleading, close enough to being actually wrong (and this includes the manufacturer s official documentation). Be prepared to spend a good portion of your time beating your head against a wall. But you have options the instructor will hopefully safeguard your mental stablity. Use as necessary!

10 Prerequisites (Part 5) That said, operating system development is some of the most frustrating and also the most rewarding programming you may ever do. To know that your code is the only code running on the machine is a kind of power. It is at once sobering and comforting, knowing that any minor glitch could send it hurtling into a rebooting inferno, but that despite this the machine is still humming blithely along. It s difficult to add to that observation about the significance of operating systems in the entire spectrum of software used on computing systems. Simply put, the OS is the preeminent required software on a computer.

11 Prerequisites (Part 6) Concepts from a previous OS course: Concurrent programming: you should have written a program that uses fork or the equivalent Understanding of deadlock and race conditions I/O: you should know the difference between standard library functions (e.g., fopen, putc, getc, fread, fwrite) and system calls (e.g., open, close, read, write) File systems and hierarchical directories Symbolic and hard links File modes and protection

12 Prerequisites (Part 7) Understanding of runtime storage components Segments (text, data, and bss) and their layout Runtime stack, activation records, and argument passing Basic heap storage management (free list) C programming At least one nontrivial program Comfortable with low-level constructs (e.g., bit manipulation and pointers)

13 Prerequisites (Part 8) Working knowledge of basic UNIX tools Text editor (e.g., vi) Compiler / linker / loader Tar archives Make and Makefiles Desire to learn

14 Course Scope This is a course about the design and structure of computer operating systems. It covers the concepts, principles, functionality, tradeoffs, and implementation of systems that support concurrent processing.

15 What We Will Cover Operating system design Functionality an operating system offers Major system components Interdependencies and system structure The key relationships between operating system abstractions and the underlying hardware (especially processes and interrupts) Implementation details

16 What You Will Learn Fundamental Principles Design options Tradeoffs How to modify and test operating system code How to design and build an operating system

17 What We Will NOT Cover Comparison of large commercial and open source operating systems Description of features or instructions on how to use a particular operating systems Survey of research systems and alternative approaches that have been studied Set of techniques for building operating systems on unusual hardware

18 How Did We Get Here? 1940s 1950s: How can computers be built? The dawn of digital computers Each processor is special-purpose Each I/O device has a unique interface Software is written in assembly language Programs are written to control the hardware

19 How Did We Get Here? (continued) 1960s: What are the best abstractions to use? A move to general-purpose hardware Instruction Set Architecture emerges Families of computers devised I/O became independent of specific hardware details High-level programming languages created (e.g., parameterized functions, data types, and recursion)

20 How Did We Get Here? (continued) Late 1960s and 1970s Researchers investigate operating systems The Multics project devises brilliant abstractions Unix introduces simple, elegant, and efficient versions of the Multics abstractions 1980s and on The Internet project discovers a set of communication abstractions that are elegant and efficient All systems are connected

21 What Can We Conclude From History? The gap between hardware and users is huge. Hardware is ugly. Operating system abstractions are beautiful. Everything is connected. Data centers Desktops Smart phones Devices Sensors

22 Consequences and Observations Our job in Computer Science is to build beautiful new abstractions that fill the gap between ugly hardware and users. We cannot consider operating systems without including computer networking. The central questions in computing have always focused on the tradeoff between imagined beauty and performance. It is easy to imagine new abstractions. We must restrict ourselves to abstractions that map onto the underlying hardware efficiently (and hope that hardware engineers eventually adapt to our abstractions).

23 The Once and Future Hot Topic In the 1970s and early 1980s, operating systems was one of the hottest topics in CS By the mid-1990s, OS research had stagnated Now things have heated up again, and new operating systems are being designed for Multicore systems Data centers Smart phones Large and small embedded devices The Internet of Things

24 THE XINU OPERATING SYSTEM

25 Motivation for Using a Real System Provides examples of the principles Makes everything concrete Gives students a chance to experiment Shows how abstractions map to real hardware

26 Why Xinu? Small can be read and understood in a semester Complete includes all the major components Elegant provides an excellent example of clean design Powerful has dynamic process creation, dynamic memory management, and flexible I/O Practical has been used in real products

27 The Laboratory Environment In progress

28 How We Will Proceed We will examine the major components of an operating system For a given component we will Outline the functionality needed Learn the key principles involved Understand one particular design choice in depth Consider implementation details and the relationship to hardware Discuss other possibilities and tradeoffs Note: we will cover components in a linear order that allows us to understand one component at a time without relying on later components.

29 FINALLY, A FEW THINGS TO CONSIDER

30 Perfection [in design] is achieved not when there is nothing to add, but rather when there is nothing more to take away. Antoine de Saint-Exupery

31 A teacher s job is to make the agony of decision making so intense you can only escape by thinking. source unknown

32 Real concurrency in which one program actually continues to function while you call up and use another is more amazing but of small use to the average person. How many programs do you have that take more than a few seconds to perform any task? (From an article about new operating systems for the IBM PC in the New York Times, 25 April 1989)

33 Anything sufficiently weird must be fishy. (The ultimate rule as suggested by Captain Shi Qiang in The Three-Body Problem by Cixin Liu)

CS 153 Design of Operating Systems

CS 153 Design of Operating Systems Winter 19 Lecture 2: Historical perspective Instructor: Nael Abu-Ghazaleh Last time What is an OS? What roles does it play? Today: Historic evolution of Operating Systems