CSUMB Learning Journal

There was a lot of reading to do this week. We learned mainly about semaphores and common concurrency problems. Semaphores are a synchronization primitive that combines the uses of locks and condition variables to solve problems with concurrency. Semaphores are objects that contain an integer value that can be manipulated with two routines to increment and decrement the value to manage system resources. The common concurrency problems chapter goes over different types of bugs present in modern applications like non-deadlock bugs and order-violation bugs. Non-deadlock bugs are very common, but easy to fix because they are usually atomicity violations or order violations. Deadlock bugs are a little more complicated but they can be solved by proper scheduling.

The topic of this week was concurrency. We learned about threads and how multi-threading can be more efficient, but introduces new problems that occur when trying to schedule threads. That’s where we dive in the idea of locks and how they atomize critical sections of code. Locks are used by the task scheduler to enable the use of concurrent threads without causing race conditions and other issues that prevent programs from executing properly. These concepts reminded me of database locks, it’s basically the same idea. The chapters we read also cover the concepts of lock-based concurrent data structures and condition variables which are another necessary component of scheduling for multiple threads.

This week required a lot of reading. The module focused on memory virtualization in operating systems and what paging is and how it works. Last week was also about memory virtualization, but it’s getting more complicated. The part that I found difficult was understanding and being able to convert virtual addresses to physical addresses. That wasn’t very fun to do, but it is a process designed for computers instead of humans so that makes sense. I found the reading to be interesting and it’s nice seeing stuff we learned before like the FIFO algorithm being used in regards to memory paging.

This week I learned a lot more about memory virtualization. I already knew about it a bit but this module helped expand my understanding of the subject. Programming assignment 3 was also very educational getting to debug and write functions for a memory allocation library. I think it really helped me better understand how memory is managed. One thing that stood out to me when I first looked at this assignment was that the code for allocating memory looked very very familiar. It reminded me of the concept of linked lists that I learned about in a previous class about C++. There are clear differences but they are both very similar looking data structures.

Last week I made the mistake of spending way too much time working on the programming assignment and couldn’t submit the journal entry on time, and after looking at the rubric saw that late submissions get 0 points so I just didn’t bother. So here we are in week 2 with the first journal entry for this class. Most of the reading this week was about processes and process scheduling. I also learned a bit more about what Shells are and what they can be used for. I learned a lot from PA2 as well, although I couldn’t get it working 100%... I’d also like to add that the learning portion of Lab 2 didn’t help with the practice very much because it basically only helped me figure out the formulas for calculating response times and TAT for when the processes started simultaneously. Maybe I just suck at math but it was a lot harder to figure out how to calculate those values efficiently when the processes all start at different times.