Programming problem Use either multithreading (Java or OpenMP) libraries to parallelise the following: 1) Write a program that launches 1,000 threads. Each thread adds 1 to a variable sum that initially is 0. Define a variable to hold sum. - Run the program without synchronization. - Run the program with synchronization in three different techniques 2) Write a program to compute a factorial of a given number in parallel

Programming problem Use either multithreading (Java or OpenMP) libraries to parallelise the following: 1) Write a program that launches 1,000 threads. Each thread adds 1 to a variable sum that initially is 0. Define a variable to hold sum. - Run the program without synchronization. - Run the program with synchronization in three different techniques 2) Write a program to compute a factorial of a given number in parallel

Systems Architecture

7th Edition

ISBN:9781305080195

Author:Stephen D. Burd

Publisher:Stephen D. Burd

Chapter11: Operating Systems

Section: Chapter Questions

Problem 3VE

See similar textbooks

Similar questions

Fill in the blanks:5. The ( 6 ) is used to implement mutual exclusion where it can be decremented by aprocess and incremented by another, but the value must either be 0 or 1.6. If deadlock prevention approach is used to deal with deadlocks in a system, the ( 7 )condition can be prevented using the direct method.7. Two threads may share the memory space, but they cannot share the same ( 8 )8. Consider round-robin (RR) scheduling algorithm is implemented with 2 seconds timeslice and it is now selecting a new process; if we have 3 blocked processes (A, B, and C),and A has been waiting the longest, then A would need to wait a period of ( 9 ) secondsto be selected.9. In real-time systems, if a task appears at random times, then it is considered ( 10 ).
Describe a way to achieve mutual exclusion among a certain number (more than two) of threads in a purely algorithmic manner. Write the pseudocode for what each thread needs to do to achieve mutual exclusion in this manner. Note that your solution must be purely algorithmic. In other words, you cannot depend on any special CPU hardware features (e.g. interrupt disabling or test-and-set instructions) or use OS provided tools like a semaphore.
First, generate a series of random points as simple (x, y) coordinates. These points must fall within the Cartesian coordinates that bound the square. Of the total number of random points that are generated, some will occur within the circle. Next, estimate by performing the following calculation: π = 4 × (number of points in circle) / (total number of points) Write a C program that creates several threads, each of which generates random points and determines if the points fall within the circle. Each thread will have to update the global count of all points that fall within the circle. Protect against race conditions on updates to the shared global variable by using mutex locks.
When do you use primitives like load linked and store conditional? 1. When cooperating threads of a parallel program need to synchronize to get proper behavior for reading and writing shared data 2. When cooperating processes on a uniprocessor need to synchronize for reading and writing shared data
In C++, not C please! Assume that your computer has 4 CPUs. Write a multithreaded program that runs 4 different threads concurrently. The entire process will add the first 1,000,000 numbers (from 1 to 1,000,000) to a shared variable sum. You need to use a pthread_mutex_t to provide mutual exclusion so that the final result of sum is 500,000,500,000 Note: you can download and modify the file summation_thread_shared_sum.cpp. This file does not use a mutex lock, so the result is incorrect. You must add a mutex lock correctly in the file so that the program generates the right outcome.
True or False: Threads that are part of the same process share the same stack. Briefly explain your answer.
C+++ #include <iostream>#include <pthread.h>#include <stdlib.h> #define TOTAL_THREADS 4 int count;pthread_mutex_t the_mutex; // phread mutex variable - initialize here if using the initializer macro void* myFunction(void* arg){int actual_arg = *((int*) arg);for(unsigned int i = 0; i < 10; ++i) {// TODO:// Use a Pthread mutex to control// access to the critical region. // Beginning of the critical regioncount++;std::cout << "Thread #" << actual_arg << " count = " << count << std::endl; // End of the critical region// TODO:// Relinquish access to the Pthread mutex// since critical region is complete. // Random wait - This code is just to ensure that the threads// show data sharing problemsint max = rand() % 100000;for (int x = 0; x < max; x++);// End of random wait code}pthread_exit(NULL);} int main(){int rc[TOTAL_THREADS];pthread_t ids[TOTAL_THREADS];int args[TOTAL_THREADS];// TODO: Initialize the pthread mutex here if using the…
Fibonacci Series and reverse order with two threads: Write a JAVA program which will generate the threads: 1. To display 45 terms of Fibonacci series. 2. To display 1 to 45 in reverse order.
A deadlock condition can occur in concurrent code if two or more threads each hold a resource and are waiting for another thread to release a resource they need to proceed. Question 10 options: True False
#include <iostream>#include <pthread.h>#include <stdlib.h> #define TOTAL_THREADS 4 int count;pthread_mutex_t the_mutex; // phread mutex variable - initialize here if using the initializer macro void* myFunction(void* arg){int actual_arg = *((int*) arg);for(unsigned int i = 0; i < 10; ++i) {// TODO:// Use a Pthread mutex to control// access to the critical region. // Beginning of the critical regioncount++;std::cout << "Thread #" << actual_arg << " count = " << count << std::endl; // End of the critical region// TODO:// Relinquish access to the Pthread mutex// since critical region is complete. // Random wait - This code is just to ensure that the threads// show data sharing problemsint max = rand() % 100000;for (int x = 0; x < max; x++);// End of random wait code}pthread_exit(NULL);} int main(){int rc[TOTAL_THREADS];pthread_t ids[TOTAL_THREADS];int args[TOTAL_THREADS];// TODO: Initialize the pthread mutex here if using the…
USE SIMPLE PYTHON MULTI THREADING code to perform parallel array summing. replace the mthod of using processes to complete and use threading techniques to do the same the thing. 1) Basic version with two levels of threads (master and slaves)One master thread aggregates and sums the result of n slave-threads where each slavethread sums a different range of values in an array of 1000 random integers (please program to generate 1000 random integers to populate the array). The number of slave-threads is a parameter which the user can change. For example, if the user chooses 4 slave threads, each slave thread will sum 1000/4 = 250 numbers. If the user chooses 3 slave threads, the first two may each sum 333 numbers and the third slave threadsums the rest 334 numbers. 2) Advanced version with more than two levels of threadsThe master thread creates two slave-threads where each slave-thread is responsible to sum half segment of the array. Each slave thread will fork/spawn two new…
Use both Mutex lock and Semaphore to address the racing problem in the following program (example_thread.c). Please make sure that your output is always equal to 6,000,000. ====================================== example_thread.c ====================================== #include <stdio.h>#include <stdlib.h>#include <pthread.h>int shared= 0;void race(void);int main(){ pthread_t player1, player2, player3; pthread_create(&player1, NULL, (void *)race, NULL); pthread_create(&player2, NULL, (void *)race, NULL); pthread_create(&player3, NULL, (void *)race, NULL); pthread_join(player1, NULL); pthread_join(player2, NULL); pthread_join(player3, NULL); printf("Total Number = %d\n", shared); return 0;}void race(void) { long i,tmp; for(i=1; i<=2000000; i++) { tmp = shared; tmp = tmp + 1; shared = tmp; }}