CST 334 - Week 6

 Hey everyone!
    This week we submitted our research collab project. It was quite interesting and fun. I learned a lot and our team bonded more as well. We also learned many new things through our lectures and labs. 

    Concurrency is a critical concept in computer systems, enabling multiple processes to execute simultaneously. However, with great power comes great complexity. 

    A semaphore is a synchronization primitive that helps manage access to shared resources in a concurrent environment. Semaphores can be thought of as counters that control the number of processes allowed to access a resource. They come in two main types:

         - Counting Semaphores: These can have values greater than one and are often used to manage a  pool of resources, such as threads or connections.

        - Binary Semaphores: These function like locks and can only have two values—0 (locked) or 1 (unlocked).

    Some basic operations are: 

        - Wait (P): Decreases the semaphore value. If the value is already zero, the process waits until it becomes positive.

        - Signal (V): Increases the semaphore value, potentially waking up a waiting process.

    Semaphores are widely used for implementing synchronization patterns such as mutual exclusion (ensuring only one process accesses a resource at a time) and signaling (allowing one process to notify another).

    Concurrency introduces challenges that can lead to incorrect program behavior. Some of the most common problems include:

    - The Producer-Consumer Problem

        A producer generates data and places it in a shared buffer, while a consumer removes data from the buffer. Synchronization is needed to:

        - Ensure the producer doesn’t add to a full buffer.

        - Prevent the consumer from removing from an empty buffer.

     - The Readers-Writers Problem

        This problem occurs when multiple readers and writers access a shared resource:

        - Readers can read simultaneously.

        - Writers require exclusive access.

      - Deadlock: 

            Deadlock occurs when a set of processes are blocked, each waiting for a resource held by another. Deadlock prevention strategies include:

        - Ensuring resources are requested in a specific order.

        - Using a timeout mechanism to break cycles.

    While semaphores are powerful, they can be challenging to use correctly due to the potential for subtle bugs like missed signals or deadlocks. Monitors provide a higher-level abstraction for synchronization. Some key features of monitors are:

        - Encapsulation: Monitors bundle shared variables and methods for accessing them.

        - Automatic Mutual Exclusion: Only one process can execute a monitor’s methods at a time.

        - Condition Variables: Monitors use condition variables and operations like "wait" and "signal" to manage synchronization internally.

    Monitors are often preferred in high-level programming languages because they simplify the implementation of concurrency control, making the code easier to read and maintain.

    Semaphores and monitors are essential tools for managing concurrency in modern computing systems. By understanding their operation and the common problems they address, developers can design more robust and efficient software. Mastering these concepts requires practice, so consider experimenting with simple implementations to deepen your understanding.

    That is it for this week. I am looking forward to meeting you all next week!

Comments

Post a Comment

Popular posts from this blog

CST 334 - Week 4

Hey everyone!       This week, I learned about how operating systems manage memory, which is one of their most important jobs. One topic was free space management , where the system keeps track of memory or storage that isn’t being used. Two common methods are bitmaps (using bits to mark if memory is free or taken) and linked lists (connecting free memory blocks together). Each method has its pros and cons, like how much space they use or how fast they work.      I also studied paging , which splits memory into small chunks called pages. These pages are mapped to physical memory, keeping processes separate and organized. However, this mapping can slow things down because the computer has to translate addresses often. To make it faster, Translation Lookaside Buffers (TLBs) store recent translations in a small, quick cache. I also learned about advanced page tables , which are smarter ways of organizing these mappings to save memory.    ...
Read more

CST 370 - Week 1

 Hey everyone, This week, we learned several important topics that form the foundation of computer science and programming. We started with GitHub and practiced using manual commands like git init, git add, git commit, and git push to manage our code. This helped us understand version control and how to keep track of changes when working on projects, especially when collaborating with others. We were also introduced to algorithms and learned what they are—step-by-step methods for solving problems. One example we focused on was Euclid’s Algorithm for finding the greatest common divisor (GCD) of two numbers. It uses a simple but powerful idea: repeatedly replace the numbers with GCD(b, a % b) until the second number becomes zero. We also practiced writing pseudocode, which helped us plan out algorithms in plain language before coding. We also had a homework assignment to help us further understand GitHub commands. Later in the week, we learned about graphs, both weighted and unweight...
Read more