COMP 3430 – Operating Systems
COMP 3430 – Operating Systems
Copyright By PowCoder代写 加微信 powcoder
Winter 2022
Course description
Calendar entry
Instructors
General course
description
Course goals
Course materials and
technology
Minimum technology
requirements
Class meetings
Lab meetings
Expectations and policies
Our Expectations of You
What you can
expect from your instructors
Student accessibility
synchronous sessions/online lectures
Voluntary withdrawal
Medical circumstances
Week 0: Operating system
Week 1: Processes
Week 2: Threads
Communication: IPC, pipes, signals (Lab 1)
Week 4: Scheduling
(Assignment 1)
Winter term break
Week 5: Locking and
Deadlock (Lab 2)
6: I/O, I/O scheduling, and physical representation (Term test 1,
Assignment 2)
Week 7: File
systems part 1: Implementation
8: File systems part 2: consistency and redundancy (Lab 3)
Memory part 1: physical memory (Assignment 3)
Week 10: Memory part
2: virtual memory
Week 11: Memory part
3: paging (Lab 4)
Memory part 4: swapping (Assignment 4)
Week 13: Term test 2
Course assessment
Grade Breakdown
Final grades
Extension and late
submission policy
Grade appeals
Course description
Calendar entry
COMP 3430: Operating Systems.
Operating systems, their design, implementation, and usage.
Prerequisites: one of COMP 2140 or COMP 2061 (C); and COMP 2280 (C)
or ECE 3610 (C). COMP 2160 is recommended.
3.0 Credit hours.
Instructors
address me as “Franklin”/he/him
E-mail address:
Lecture times: M/W/F 12:30–1:20pm
hours: M/W 10:30–11:30am (you should make an appointment by
address me as “Rob”/he/him
E-mail address:
Lecture times: M/W/F 1:30–2:20pm
hours: Tuesdays 10am–12pm and Fridays after class.
General course description
In the last couple of years you’ve learned a lot of new things: you’ve learned how to
program (in Processing, Python, and Java), you’ve learned how to program
better (in C), you’ve learned about how to represent
information and complex interactions between that information,
you’ve learned how to build and use data structures, you’ve learned how
to use and analyze algorithms, and you’ve learned about how computers
work at a very low level, including assembly languages.
In this course we’re going to be focusing on applying data structures
and algorithms that you’ve previously learned to the problem of
managing resources, where resources are things like CPUs, input
and output devices, and memory. You’re also going to be introduced to
the idea of concurrent programming, where we’ll start thinking
about how making it seem like a computer is doing many
different things at the same time requires a little bit of extra thought
on our part and the operating system.
We will explicitly not talk about hardware
implementation in this course, the scope of this course ends at the
interface between hardware and software. COMP 3370 (or the equivalent
computer engineering course) complements (and compliments 😍!) this course by looking
at the other side of the interface: the implementation in
Course goals
By the end of this course, students should be able to:
Write and analyze concurrent programs (processes and threads,
synchronization, communication).
Describe, implement, and analyze scheduling algorithms.
Describe and analyze strategies for managing memory (physical and
Describe, implement, and analyze data structures and algorithms used
in file systems.
Course materials and
technology
Minimum technology
requirements
Students enrolled in this course must ensure they satisfy the
following minimum technological requirements:
A computing device where one can create and edit documents, and
connect to remote systems using SSH,
An internet connection capable of streaming videos and downloading
software, and
Access to a web-cam and microphone.
Class meetings
Class meetings will happen on Zoom. Students will be put into into teams for
discussions and learning activities. Teams will be pre-assigned using
your @myumanitoba.ca e-mail address.
We will be using UM Zoom, so you must sign in through UM Learn, using
your @myumanitoba.ca e-mail address.
Lab meetings
The first lab meeting will happen on UM Zoom. Your lab demonstrator will host a Zoom
session, and the meetings will be scheduled in UM Learn. Lab sections
will not be recorded.
Required: Operating Systems: Three Easy Pieces by Remzi H
Arpaci-Dusseau and Arpaci-Dusseau. You will be assigned
readings from this book for each weekly topic.
Additional course material may be posted to UM Learn and some of
these readings may be required.
Expectations and policies
Our Expectations of You
Class Communication
You are required to obtain and use your University of Manitoba e-mail
account for all communication between yourself and the university
(including the course instructors). All communication must comply with
the Electronic Communication with Students Policy.
You should not contact lab demonstrators outside of your scheduled
lab times, and you should not contact graders for the course at all. The
lab demonstrators and graders have been instructed to ignore any
communication from students. Any questions or concerns about grades
relating to labs or assignments should be directed to your
instructor.
Academic Integrity
Each student in this course is expected to abide by the University of
Manitoba Academic Integrity Principles. Always remember to
reference the work of others that you have used. Also be advised that
you are required to complete your assignments independently unless
otherwise specified. If you are encouraged to work in a team, ensure
that your project complies with the academic integrity regulations. You
must do your own work during exams. Inappropriate collaborative
behaviour and violation of other Academic Integrity Principles will lead
to serious disciplinary action. You should visit the Academic
Integrity Principles and Faculty of Science Cheating and Plagiarism pages for
more information and support.
More specifically, in this course:
Assignments must be done independently by each student. See the
details in the Honesty Declaration on the website. Help may be obtained
from the course instructors, or from the course teaching assistants.
Assistance from other students may only be of a very general and
non-specific nature. Every line of code in every program must be
written, entered, corrected, and edited solely by the individual
student. Code must never be taken from another student, a website, a
book, or any other source, except as specified in an assignment.
Students are not permitted to share their code with, or show their code
to, any other students in the course.
Special purpose software will be used to cross-check every assignment
submitted by every student against all other students’ assignments and
possibly against other known relevant code sources, including student
work submitted in previous offerings of this course.
Academic misconduct may result in a zero on a test or assignment, a
grade of F in the course along with a notation of academic misconduct on
your transcript, and/or suspension from taking classes in the Faculty of
What you can expect
from your instructors
We will return assessments on assignments before the next assignment
We will return tests/quizzes/etc within 2 weeks of their
submission.
We will use a variety of teaching strategies in the classroom.
We are open to suggestions for course material from students.
We will reply to e-mails or forum posts within 3 business days.
We will not reply to e-mails or forum posts on
weekends, holidays, or outside of business hours (We define business
hours as 9:00am–3:00pm M–F).
Student accessibility
The University of Manitoba is committed to providing an accessible
academic community. Student Accessibility Services (SAS) offers academic
accommodation supports and services such as note-taking, interpreting,
assistive technology and exam accommodations. Students who have, or
think they may have, a disability (e.g., mental illness, learning,
medical, hearing, injury-related, visual) are invited to contact SAS to
arrange a confidential consultation.
Student Accessibility Services
520 University Centre
Phone: (204) 474-7423
synchronous sessions/online lectures
All material published as part of this courses is copyright and/or , 2022. Course materials are for the
participant’s private study and research, and must not be shared.
Violations of these and other Academic Integrity Principle, will lead to
serious disciplinary action.
Voluntary withdrawal
The last day to revise your course registration is February
6th 20221. If you drop the course on or before
this date, the course will not appear on your transcript at all.
The last day to withdraw voluntarily from this course is April
25th, 20222. If you drop the course after the
revision deadline, but before this date, the course will appear on your
transcript, but no final grade will be assigned. If you do not
voluntarily withdraw from the course before the withdrawal deadline, you
will be assigned a final grade.
You can feel free to get in touch with your instructor if you have
any questions or concerns about your progress, or if you’re looking for
advice or strategies about how to improve your scores before the
voluntary withdrawal deadline.
Medical circumstances
Students who are unable to meet a course requirement due to medical
circumstances are currently not required to submit medical notes.
However, students are required to contact their instructor or academic
advisor by email to inform of the missed work and make arrangements for
extensions, deferrals, or make-up assignments. Please follow these
guidelines if you are unable to meet an academic requirement for your
Contact your instructor for term work such as a class, quiz,
midterm/test, assignment, lab
Contact an advisor in your faculty of registration for a missed
final exam (scheduled in the final examination period)
Inform your instructor/advisor as soon as possible do not delay.
Note for final exams, students must contact within 48 hours of the date
of the final exam.
Email your instructor/advisor from a U of M email address, and
include your full name, student number, course number, and academic work
that was missed.
Please note that circumstances that result in missing multiple course
assessments or lectures may require medical documentation (e.g.,
Authorized Withdrawal, Tuition Fee Appeal, Leave of Absence, or accessibility-related accommodations). Students are
advised to speak with an advisor in their faculty/college/school of
registration in this case.
Below is a week-by-week breakdown of the topics we’ll be covering
this term, including the readings that you’re required to complete.
The schedule also includes due dates for assignments, weeks where you
will have labs, and dates for term tests.
The schedule also includes recommended exercises (for all
the free time that you have…) from the MIT course called “The Missing
Semester of Your CS Education”. These exercises are entirely
optional and are not for credit, but will help you improve your
command-line skills.
This schedule is subject to change at the discretion of the
instructor and/or based on the learning needs of the students, but such
changes are subject to Section 2.8 of ROASS Procedure.
Week 0: Operating system
This week we’re going to be trying to define what an operating system
(OS) is. We’re going to figure out what kinds of
responsibilities an OS has, the abstract parts of an OS, and where and
how an OS interacts with hardware (at an extremely high level,
we’re going to revisit this later!).
While the content from week 0 is optional, it’s recommended that you
take a look at this material to give you an idea of the organization of
the textbook and the course.
Learning objectives:
There are no formal learning objectives for this part of the
Chapters to read (optional):
Preface, specifically the section “To Students”
Chapter 2 Introduction to Operating Systems
Week 1: Processes
January 24th–28th, 2022
One of the main responsibilities that an OS has (at least in
terms of the way that we as users interact with it) is running
programs. This week we’re also going to look at two things
related to how an OS runs a program: the different ways that we
can ask an OS to run a program and the life cycle of a
Learning objectives:
Describe how a process is launched by an OS (chapter 4/5)
Write code that creates and manages a process (chapter 5)
Describe the lifecycle of a process (chapter 4)
Determine what an OS might need to know about a process.
Describe how an operating system manages processes (chapter 6,
Data structures, control of processor, modes, etc
Define and describe context switching and mode switching (chapter 6,
Define the term “system call” (chapter 6, video)
Chapters to read:
Chapter 4 The Abstraction: The Process
Chapter 5 Interlude: Process API
Chapter 6 Mechanism: Limited Direct Execution
(summary video will be posted)
Recommended lab activities:
The missing semester: “the shell” (you can safely
skip the course overview)
The missing semester: “Editors (Vim)”
Week 2: Threads
January 31st–February 4th,
While processes are a mechanism to do multiple things at the
same time (and they do a great job of it), and while
they work well enough in many situations, they aren’t the only
way for an OS to run multiple things at the same time. This week we’re
going to be looking at threads, a more granular (i.e., finer-grained) approach to
doing multiple things at the same time. We’re going to spend some time
comparing and contrasting processes and threads to see how they’re
different, and the kinds of circumstances where you might want to choose
one over the other.
Learning objectives:
Compare and contrast threads and processes (chapters 4, 5, 26, 27,
Write a program that creates and runs threads (chapter 27)
List problems that come up with concurrent code (chapter 26,
Explain what locks are, and how they solve the problems that come up
with concurrent code (chapter 26, video)
Write a program that uses locks or condition variables to control
access to a critical section (chapter 27)
Choose and use appropriate strategies for reducing costs associated
with threads.
Compare and contrast pthread locks and condition variables (chapter
26, chapter 27)
Chapters to read:
Chapter 26 Concurrency: An Introduction (summary
video will be posted)
Chapter 27 Interlude: Thread API
Recommended lab activities:
The missing semester: “Command-line
Environment”
Communication: IPC, pipes, signals (Lab 1)
February 7th–11th, 2022
Lab 1 happens this week. You should attend the lab section that
you are registered for.
While we’re now able to do multiple different things at the same
time, one of the differences that we uncovered between threads and
processes is that processes have no way to talk to one another
after they’re launched. Threads can implicitly talk to one
another in that they are part of the same process.
This week we’re going to spend some time looking at different methods
a process can use to communicate with other processes; interprocess
communication or IPC.
Learning objectives:
Describe different strategies for IPC (APUE, video)
Write a program that sends and handles signals (video)
Write a program that communicates between processes with anonymous
pipes (APUE, video)
Write a program that communicates between processes with FIFOs
(named pipes) (APUE, video)
Describe what responsibilities an OS has in terms of implementing
signals, pipes, and FIFOs
Compare and contrast regular files with pipes.
Implement a client/server architecture using signals, pipes, and
FIFOs. (APUE, video)
Required reading:
Specific sections from Chapter 15
of Advanced Programming in the UNIX Environment. (summary video will
be posted)
Section 15.1: Introduction
Section 15.2: Pipes (you can safely ignore the last example in this
section, implementing the TELL and WAIT
functions using pipes)
Section 15.3: popen and pclose
Section 15.5: FIFOs
Some manual pages (only signal, kill, and
raise are strictly required right now, pipe
and mkfifo are for your reference for now, but will be used
signal(7) or man 7 signal
on aviary.
signal(2) or man 2 signal
on aviary.
kill(3) or man 3 kill on
raise(3) or man 3 raise on
pipe(3) or man 3 pipe on
mkfifo(3) or man 3 mkfifo
on aviary.
Recommended lab activities:
The missing semester: “Shell Tools and
Scripting”
Week 4: Scheduling (Assignment
February 14th–18th, 2022
Assignment 1 is due on Friday, February 18th, 2022
at 4:30pm 11:59pm CDT.
At this point we’ve spent a lot of time thinking about how to
get the OS to do stuff for us, specifically: how do we get the
OS to run code so that it seems like different things are
running at the same time. Now we’re going to look at specifically that:
how does an OS execute the code of different programs to make
it seem like more than one thing is running at the same time?
Scheduling is going to take us into applied data structures:
we’ll be looking at different kinds of queues!
Learning objectives:
Compare and contrast preemptive and non-preemptive (cooperative)
multitasking. (Chapter 7, also chapter 6 in terms of context
switching)
Compare and contrast different scheduling policies. (Chapter 7, 8,
Evaluate the performance of scheduling policies. (Chapter 7)
Write a UNIX program that implements scheduling policies. (Chapter
Describe a scheduling algorithm in the Linux kernel.
Chapters to read:
Chapter 7 Scheduling: Introduction
Chapter 8 Scheduling: The Multi-Level Feedback Queue
(video summary will be posted)
Chapter 9 Scheduling: Proportional Share (only
9.1–9.5 and 9.8 are required, 9.6 and 9.7 are optional)
Winter term break
February 21st–25th, 2022
Week 5: Locking and Deadlock
February 28th–March 4th,
Lab 2 happens this week. You should attend the lab section that
you are registered for.
When we started talking about threading, we focused primarily on the
kinds of problems where threads didn’t need to communicate much with
each other. Of course, threads need to talk to each other in as
much as processes do in as much as any concurrent actor needs to talk to
someone else: we have both communication that may need to happen, but
also managing access to limited resources.
Think about this as cooks in a kitchen at a restaurant. They all have
jobs to do that are fairly similar: they all have access to the same
resources (food, ovens, fryers, etc) and they all have to coordinate
with one another to access those resources.
We’re going to look at this from two perspectives: from the
programmer’s perspective (how do I use this API?) and from the OS’s
perspective (how does an OS implement this API?).
Learning objectives:
Compare and contrast methods for building locks. (Chapter 28,
Evaluate implementations of locks. (Chapter 28, video)
Use condition variables in a program. (Chapter 30)
Identify concurrency bugs in a program (both non-deadlock and
deadlock). (Chapter 32)
Describe how to change code to prevent deadlock from happening.
(Chapter 32)
Chapters to read:
Chapter 28 Locks (Sections 28.10, 28.15, and 28.16
are optional, video summary will be posted)
Chapter 30 Condition variables
Chapter 32 Common concurrency bugs
6: I/O, I/O scheduling, and physical representation (Term test 1,
Assignment 2)
March 7th–11th, 2022
Term test 1 will take place in-class during
scheduled class time on Friday, March 11th.
Assignment 2 is due on Friday, March 11th at
程序代写 CS代考 加微信: powcoder QQ: 1823890830 Email: powcoder@163.com