Week 30

 CST-334 Week 6

This is our sixth week in CST-334, also known as Operating Systems.

Operating Systems: Three Easy Pieces

This week we read chapters 30-32 of our textbook.

Chapter 30: Condition Variables

Chapter 30 discusses condition variables.

Key Takeaways:

  • Threads can use condition variables to check if a condition is true before executing.
  • Condition variables are queues that threads can wait on. Waiting threads can then be woken when the condition variable changes.
  • The function pthread_cond_wait(cond, mutex) adds a thread to the queue, releases the lock, and puts it to sleep. Cond is the condition variable. Mutex is the lock.
  • The function pthread_cond_signal(cond) wakes the next thread in the queue and gives it the lock. Cond is the condition variable.
  • You should use while loops instead of if statements when checking a condition variable. 

Chapter 31: Semaphores

Chapter 31 discusses semaphores.

Key Takeaways:

  • A semaphore is an object that contains an integer. It is used as both a lock and condition variable.
  • The function sem_init(m, 0, x) initializes a semaphore. M is the semaphore. 0 indicates that the semaphore will be shared between threads. X is the starting value of the semaphore.
  • The function sem_wait(m) decrements the semaphore and either returns if the semaphore was 1 or higher, or puts the thread to sleep. M is the semaphore.
  • The function sem_post(m) increments the semaphore and wakes one of the threads waiting on the semaphore. M is the semaphore.
  • When a semaphore is negative, the value is equal to the number of threads waiting on said semaphore.

Chapter 32: Concurrency Bugs

Chapter 32 discusses common concurrency bugs in concurrent programs.

Key Takeaways:

  •  Atomicity-violation bugs happen when a section of code is intended to be atomic is run un-atomically. Locks can be used to prevent them.
  • Order-violation bugs happen when code that is intended to run in a certain order, such as one thread 1 running before thread 2, runs in an intended order, such as thread 2 running before thread 1. Condition variables can be used to prevent them. 
  • A large portion of non-deadlock bugs are atomicity or order violations.
  • Deadlock occurs when threads are waiting for other threads to release locks while the threads themselves are holding the locks being waited on.
  • Four conditions need to be true for Deadlock to occur:
    • Mutual exclusion
    • Hold-and-wait
    • No preemption
    • Circular wait
  • To prevent deadlocks one can:
    • Order lock acquisition to prevent circular waiting.
    • Acquire all locks at once to prevent hold-and-wait.
    • Preempt locks.
    • Eliminate the need for mutual exclusion.
  • Deadlocks can be avoided by scheduling threads so that no threads require the same locks at the same time. 

 

Comments

Post a Comment

Popular posts from this blog

Week 11

CST-338 Week 3  This week was the third week of CST-338. In this week we continued to learn more design and Java concepts. Black Box & White Box Testing This week we learned about two methodologies used for testing programs, black box and white box testing. Black box tests only focuses on the input, output, and functionality of a program, and not the internal code, logic, or structure of a program. One of the advantages of black box tests is that they are simple and easy to run. White box tests focus on the code, logic, and structure of a program. One of the advantages of white box tests is that can find logical errors, security vulnerabilities, or inefficiencies in code. Coupling & Cohesion This week we learned about coupling and cohesion in objects and methods. Coupling refers to how much different classes rely on each other. If two classes have tight coupling then they are more dependent, and changes in one are more likely to affect the other. If two classes have loose c...
Read more

Week 12

CST 338 - Week 4 This week was the fourth week is CST 338, also known as Software Engineering. In this week we began to learn about android development. Project 1 Review This week we finished a large project in CST 338. We have been asked to work with one or more classmates, and answer some questions about the project. With whom did you work? I worked with Nasser. What was your strategy for solving the assignments? My strategy was to read all of the method descriptions before I wrote any code. As I read them I created method stubs, and detailed TODO comments for each method. Afterwards, I started writing the methods from top to bottom in the assignment prompt. If a method called another method that I had not written yet, I would go ahead and write that method first so I better understood how they interacted. What was their strategy for solving the assignments? Their strategy was to follow the instructions closely as is, by following the UML diagrams and prompt as closely as possible. ...
Read more

Week 19

Image
 CST-363: Week 3 This is the third week of CST-363, also known as Intro. to Databases. Questions What is an SQL view.  How is it similar to a table? In what ways is it different? An SQL View stores a SELECT statement for later use, allowing the statement to be easily accessed in the future. A View functions similarly to a table, because SELECT statements return tables. However, the values that a View shows aren't being stored in the View, but the actual tables. This means that when one of those tables is updated, the View has to be as well. This also means that one needs to be very careful with updating or deleting rows using the View. Take a minute to think about how SQL compares to other programming languages like Java. What features are similar, and which are present in one language but not the other? The first and most clear difference is the syntax. SQL syntax is very different from that of Java and other programming languages. I think this makes basic SQL commands easy t...
Read more