Problem 2. In addition to POSIX semaphores, the POSIX threads standard provides another useful synchronization primitives: the muter (type pthread_mutex_t) A mutex is used to wait for it implement mutual exclusion. A thread locks a mutex variable by calling pthread_mutex_lock(), and unlocks it by calling pthread_mutex_unlock(). When a thread calls pthread_mutex_lock() while another thread has previously locked the same mutex but not yet unlocked it, the former thread blocks until the latter thread calls pthread_mutex_unlock() on it. a. Is there any difference between a binary semaphore and a pthread_mutex? Justify your answer. b. Consider a program with multiple threads running this function: struct {...} shared_data; pthread_mutex_t m; void *thread_func(void *arg) { [update shared_data]; // critical section! return NULL; } Assume the mutex is initialized before the threads are created. Add the necessary pthread_mutex_* calls to the above code to ensure that only one thread is in the critical section at any time. c. Consider the program below, where ". . ." represents code that updates a shared data structure.

Problem 2. In addition to POSIX semaphores, the POSIX threads standard provides another useful synchronization primitives: the muter (type pthread_mutex_t) A mutex is used to wait for it implement mutual exclusion. A thread locks a mutex variable by calling pthread_mutex_lock(), and unlocks it by calling pthread_mutex_unlock(). When a thread calls pthread_mutex_lock() while another thread has previously locked the same mutex but not yet unlocked it, the former thread blocks until the latter thread calls pthread_mutex_unlock() on it. a. Is there any difference between a binary semaphore and a pthread_mutex? Justify your answer. b. Consider a program with multiple threads running this function: struct {...} shared_data; pthread_mutex_t m; void thread_func(void arg) { [update shared_data]; // critical section! return NULL; } Assume the mutex is initialized before the threads are created. Add the necessary pthread_mutex_* calls to the above code to ensure that only one thread is in the critical section at any time. c. Consider the program below, where ". . ." represents code that updates a shared data structure.

Systems Architecture

7th Edition

ISBN:9781305080195

Author:Stephen D. Burd

Publisher:Stephen D. Burd

Chapter11: Operating Systems

Section: Chapter Questions

Problem 14VE

See similar textbooks

Similar questions

Write complete Java code to define a thread for printing all the Odd Nos from 1 to 5000 which are divisible by 9. Thread must sleep for 5 seconds. Implement the threading using the Runnable java provided Interface. Finally, create three different threads with names ThreadOne, ThreadTwo and ThreadThree in main(). Execute the code in the file where threading is implemented. Apply the Java multithreading exception handling mechanism properly
1)Write a complete multi-threaded Java program to find product of 2 matrices of any size. Write a Driver class containing main method to read dimensions and the elements of 2 matrices from keyboard. Check whether the two matrices are compatible for multiplication or not. If not, throw an user defined exception called IncompatibleMatrixException. Write a MatThread class using Runnable interface. Each thread will find one row of a resultant matrix. Pass only the necessary data to the thread class constructor. Display the rows of the resultant matrix from respective threads along with the thread names like Row 0, Row 1 etc.
Allocation Мах Available АВCD АВСD АВСD То T1 T2 T3 0012 0012 1520 1000 1750 1354 2356 0632 0014 0652 0656 Answer the following questions using the banker's algorithm: a. What is the content of the matrix Need? b. Is the system in a safe state? c. If a request from thread T1 arrives for (0,4,2,0), can the request be granted immediately? 2)
1. Implement mutual exclusion with multithreading in Java Build a Java program which simulates a communication between a server and clients. You must use a thread to represent each party (as server or client). (Hint: study about the Semaphore class to perform mutual exclusion between threads) Create three threads. One thread will act as a server, which always ready to receive a message from a client (ping) and then replies the message to the same client (pong). The other two threads will become the clients, where each client will send a message to the server (ping) and waits for the reply (pong). Define 2 different classes to represent the server and the client. To perform the communication, each thread will refer to a same variable/data structure for sending and receiving the message. Use mutual exclusion approach to ensure each client can send and receive the reply without interruption from any other elient(s). For this simulation, your objective is to ensure that each client must…
Use semaphores to build a no-starve mutex, in which any thread that tries to acquire the mutex will eventually obtain it. Use code below. #include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <pthread.h>#include "common_threads.h" typedef __ns_mutex_t {} ns_mutex_t; void ns_mutex_init(ns_mutex_t *m) {} void ns_mutex_acquire(ns_mutex_t *m) {} void ns_mutex_release(ns_mutex_t *m) {} void *worker(void *arg) {return NULL;} int main(int argc, char *argv[]) {printf("parent: begin\n");printf("parent: end\n");return 0;}
Complete the following code. The goal is to implement the producer-consumer problem. You are expected to extend the provided C code to synchronize the thread operations consumer() and producer() such that an underflow and overflow of the queue is prevented. You are not allowed to change the code for implementing the queue operations, that is the code between lines 25 and 126 as shown in the screenshot. You must complete the missing parts as shown in the screenshot as well as complete the missing codes of producer and consumer. #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> #include <pthread.h> #include <semaphore.h> #include <errno.h> #include <fcntl.h> #define MAX_LENGTH_CAP 100 #define INIT -127 #define UNDERFLOW (0x80 + 0x02) #define OVERFLOW 0x80 + 0x01 #define BADPTR (0x80 + 0x03) #define CONSUMER_TERMINATION_PROBABILITY 40 #define PRODUCER_TERMINATION_PROBABILITY 30 // ============= LOCKED…
Implement a Multithreaded Sudoku Solution Validator using POSIX thread library in C Specifications This assignment consists of designing a multithreaded application that determines whether the solution to a Sudoku puzzle is valid. A Sudoku puzzle uses a 9×9 grid in which each column and row, as well as each of the nine 3×3 subgrids, must contain all of the digits 1 to 9. Following figure presents an example of a valid Sudoku puzzle solution. There are several different ways of multithreading this application. In this assignment, you need to implement the strategy to create multiple worker threads that check the following criteria: Nine threads to check that each of the 9 columns contains the digits 1 through 9 Nine threads to check that each of the 9 rows contains the digits 1 through 9 Nine threads to check that each of the 3×3 subgrids contains the digits 1 through 9 This would result in a total of 27 separate worker threads for validating a Sudoku puzzle solution.The parent…
JAVA You are requested to implement a “message buffer and response connector” class using Javaprogramming language. The following figure depicts a message buffer and response connectorclass, followed by detailed operations specifications. The message buffer and response connectorclass has three operations, send(), receive(), and reply().Your program should create two separate threads for testing your implementation, a producerthread, and a consumer thread. The producer thread sends a message having a structure (string,integer) – e.g., (add, 3) or (multiply, 7) - to a consumer thread via a message buffer and responseconnector. The consumer thread encapsulates a SimpleCalculation class that has two operations,add() and “multiply(). You should implement the SimpleCalculation class as well. When theconsumer thread receives a message from the connector, it extracts the message and then callsone of the operations on the SimpleCalculation class, depending on the message. For example,the…
Write java code to create a thread by (extending), theprogram create 3 thread that displaying “fatmah” and thenumber of thread that is running.Rewrite the above program by implementing the RunnableInterface
Implement the producer consumer problem (also known as bounded buffer problem) in java. create two threads i.e. the producer thread and the consumer thread. Create a shared buffer object using a LinkedList or Queue. The producer adds data to the buffer and the consumer removes data from the buffer. The producer cannot add data if the buffer is full and the consumer cannot remove data from the buffer if it is empty. Make sure there are no race conditions and deadlocks.
in java fx Write a program that launches 1,000 threads. Each thread adds 1 to a variable sum that initially is 0. You need to pass sum by reference to each thread. In order to pass it by reference, define an Integer wrapper object to hold sum. Run the program with and without synchronization to see its effect.
Complete the following code. The goal is to implement the producer-consumer problem. You are expected to extend the provided C code to synchronize the thread operations consumer() and producer() such that an underflow and overflow of the queue is prevented. You are not allowed to change the code for implementing the queue operations, that is the code between lines 25 and 126 as shown in the Figure below. You must complete the missing parts between lines 226-261 as shown in the screenshot.