Eventually Consistent

CS6200 - Introduction to Operating Systems

Author

Introduction

I took GIOS in the Spring 2023 semester as part of my master's at Georgia Tech University, and it was my first course in the program. It was highly recommended for a first course in the Slack group and had great ratings in OMSCS Hub, and indeed those were on point!

The course was a great start in the program and now in my turn, I also highly recommend it to anyone interested in Computing Systems Specialization as a first course, and also provide some tips that helped me finish the course with an A.

Preparation

If your C feels kind of rusty, going over Beej's Guide will have you ready for Project 1. Other than that the final Project uses C++ but by then you will be feeling comfortable enough with C that you will be able to pick any new C++ concept needed on the spot.

I also used the OSTEP as a textbook which was recommended but not required, and I think it helped me grasp some concepts better than the lectures.

Lectures

The lectures are of high quality and concise. You can watch the lecture even without registering for the course and take a look at what they cover here. They cover a broad range of operating systems related topics like processes, threads, memory, inter-process communication, synchronization constructs, I/O management, virtualization, and more!

Projects

The course contained three projects and I found the first project to be the most challenging. Each of the projects contains two parts and for all the projects Part 2 was more difficult than Part 1. For each of the projects apart from the code you will need to submit a readme file that serves as an explanation of your code and thinking.

  • Project 1 - Multithreading

In Project 1, you are required to implement a multi-threaded that serves static files and adheres to a GetFile protocol which is described in the project instructions and is basically a simple HTTP-like protocol. Alongside you implement a multi-threaded client that downloads files from this server. In order to implement the multi-threaded server the boss-worker pattern was implemented. The boss thread(main thread), first creates a pool of worker threads when initialized, and starts an infinite loop to accept incoming GetFile requests. When a GetFile request arrives the boss thread pushes it to a queue and goes back to accept more requests. A worker thread can then pick up the request from the queue and handle it. The boss and the worker threads synchronize their access to the queue with a mutex and a condition variable that signals when items are pushed to the queue. The multi-threaded client use a similar boss-worker pattern approach, where it spawns the worker threads assigns all the work items in a queue, and then broadcasts a signal so all workers can wake up and pick up work item from the queue.

You will gain familiarity with boss-worker patterns and multithreading in this project.

  • Project 2 - IPC

In this Project, you pick up where you left off in Project 1 and evolve your multithreaded server. You will create a proxy server and cache for the GetFile server. The cache runs as a separate process from the proxy and can connect with multiple servers.

When a request arrives in the proxy server, the proxy will try to serve the request from the cache. The file contents from the cache to the proxy are transferred through shared memory. You will need to synchronize the proxy and the cache shared memory accesses with semaphores which can be quite tricky! My suggestion would be to spend some time with pen and paper thinking through this solution before trying to implement it.

You will learn about different inter-process communication mechanisms in this project, and really practice inter-process synchronization in this project.

  • Project 3 - GRPC & Distributed Systems

This is the only project that uses C++. The goal is to create a weakly consistent synchronization system to manage cache consistency between multiple clients and a single server. As with Project 2, some pre-planning with pen and paper will be invaluable, because some cases can get really tricky e.g. distinguishing between a client deleting a local file versus another client uploading a file to the server.

You will get introduced to synchronous and asynchronous GRPC with C++ in this project.

Conclusion

Overall I loved this course, At times it was a struggle but I feel I learned a ton of stuff.