Suppose we have an array of size n which stores random numbers. Also, we have n threads each of which should sum the numbers stored in the array positions from 0 to m-1 where m is the number of that thread, then stores the result in the position m-1. 215 0 25 1 17 2 1001 3 *** 5 n-2 -150 n-1 Apparently the threads can run independently, but when the array inspected after execution the results were incorrect. a) Why the results were incorrect? What is this problem called? b) How can such case be handled in order to always guarantee correct results? Suggest the most appropriate solution for this case and justify your choice. Note: No code or mathematical examples or solutions required in the answer.

Suppose we have an array of size n which stores random numbers. Also, we have n threads each of which should sum the numbers stored in the array positions from 0 to m-1 where m is the number of that thread, then stores the result in the position m-1. 215 0 25 1 17 2 1001 3 *** 5 n-2 -150 n-1 Apparently the threads can run independently, but when the array inspected after execution the results were incorrect. a) Why the results were incorrect? What is this problem called? b) How can such case be handled in order to always guarantee correct results? Suggest the most appropriate solution for this case and justify your choice. Note: No code or mathematical examples or solutions required in the answer.

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Write a program using pthreads, which calculates the sum of elements in a hard-codedinteger array in parallel using 4 threads. The program must divide the work between 4threads which run simultaneously. For simplicity, you can assume that the size of thearray is 100. Note that the integer array must be declared as a global data structure.Initially code your solution so that the sum of elements is maintained in a global shared variable. Each thread modifies the same shared variable as it sums up elements fromthe array. Use a suitable synchronization primitive (mutex) to ensure safe access to theglobal variable. (A sample code of Mutex is attached for your reference)
Try pthreads.cpp. Modify it so that they run 3 threads (instead of two) and each thread runs a different function, displaying a different message. Copy-and-paste the source code and the outputs in your report. /* pthreads_demo.cpp A very simple example demonstrating the usage of pthreads. Compile: g++ -o pthreads_demo pthreads_demo.cpp -lpthread Execute: ./pthreads_demo */ #include <pthread.h> #include <stdio.h> using namespace std; //The thread void * thread_func (void *data) { char *tname = (char *) data; printf("My thread identifier is %s\n", tname); pthread_exit (0); } int main () { pthread_t id1, id2; //thread identifiers pthread_attr_t attr1, attr2; //set of thread attributes char *tnames[2] = { "Thread 1", "Thread 2" }; //names of threads //get the default attributes pthread_attr_init (&attr1); pthread_attr_init (&attr2); //create the threads pthread_create (&id1, &attr1, thread_func,…
please i just need Clear answer with screen shot for output if needed #include <stdio.h>#include <omp.h>int main(int argc, char *argv[]) {int i, thread_id;int glob_nloops, priv_nloops; glob_nloops = 0;// parallelize this chunk of code#pragma omp parallel private(priv_nloops, thread_id){priv_nloops = 0;thread_id = omp_get_thread_num(); // parallelize this for loop #pragma omp forfor (i=0; i<100000; ++i){++priv_nloops;}// make this a "critical" code section#pragma omp critical{printf("Thread %d is adding its iterations (%d) to sum (%d), ",thread_id, priv_nloops, glob_nloops);glob_nloops += priv_nloops;printf(" total nloops is now %d.\n", glob_nloops);}}printf("Total # loop iterations is %d\n",glob_nloops); return 0;}
In this assignment, you are provided with working code that does the following: 1. You input a sentence (containing no more than 50 characters). 2. The program will read the sentence and put it into an array of characters. 3. Then, it creates one thread for each character in the sentence. 4. The goal of the program is to capitalize each letter that has an odd index. The given program actually does this, but lacks the synchronization of the threads, so the output is not correct. You will need to provide the synchronization using mutex locks. Specifically, you are to (1) declare the mutex lock, (2) initialize the mutex lock, (3) lock and unlock the mutex lock at an appropriate location that results in the code working as expected, and (4) destroy the mutex lock. Be sure to place the mutex locks so that your program works correctly every time. Do not remove code or functions – you are to add the synchronization pieces only. When compiling using the GNU C compiler, be sure to include the…
Given a sequence of ‘N’ integers. Partition the sequence into two non-empty contiguous sequences such that each element of the original sequence should appear in exactly one of these subsequences and also the product of the sum of elements in the left subsequence and the sum of elements in the right subsequence are maximum as possible. Create threads to implement this problem.Example: Given the sequence of numbers: [2 8 8 2 32]Partitioned sequences are: [2 8 8 2] , [32]Product of the sum of two sequences: [20] * [32] = 640
Modify this threading example to use, exclusively, multiprocessing, instead of threading. import threadingimport time class BankAccount(): def __init__(self, name, balance): self.name = name self.balance = balance def __str__(self): return self.name # These accounts are our shared resourcesaccount1 = BankAccount("account1", 100)account2 = BankAccount("account2", 0) class BankTransferThread(threading.Thread): def __init__(self, sender, receiver, amount): threading.Thread.__init__(self) self.sender = sender self.receiver = receiver self.amount = amount def run(self): sender_initial_balance = self.sender.balance sender_initial_balance -= self.amount # Inserting delay to allow switch between threads time.sleep(0.001) self.sender.balance = sender_initial_balance receiver_initial_balance = self.receiver.balance receiver_initial_balance += self.amount # Inserting delay to allow switch between threads time.sleep(0.001)…
Write a program using pthreads, which calculates the sum of elements in a hard-coded integer array in parallel using 4 threads. The program must divide the work between 4 threads which run simultaneously. For simplicity, you can assume that the size of the array is 100. Note that the integer array must be declared as a global data structure. Initially code your solution so that the sum of elements is maintained in a global shared variable. Each thread modifies the same shared variable as it sums up elements from the array. Use a suitable synchronization primitive (mutex) to ensure safe access to the global variable. (A sample code of Mutex is attached for your reference)...also put screenshot of output.
Now, is there a way to do this without thread pooling? Say we have a global variable maximumThreads that the user sets with the function, void setSortThreads(int count) {maximumThreads = count;} Using this global, how can we set up a basic parallelization that limits the amount of threads with the value set by this function? And, would the final solution be optimized to be faster than a version of quick sort that doesn't use threads?
please i just need screen shot for output #include <stdio.h> #include <omp.h> int main(int argc, char *argv[]) { int i, thread_id; int glob_nloops, priv_nloops; glob_nloops = 0; // parallelize this chunk of code #pragma omp parallel private(priv_nloops, thread_id) { priv_nloops = 0; thread_id = omp_get_thread_num(); // parallelize this for loop #pragma omp for for (i=0; i<100000; ++i) { ++priv_nloops; } // make this a "critical" code section #pragma omp critical { printf("Thread %d is adding its iterations (%d) to sum (%d), ", thread_id, priv_nloops, glob_nloops); glob_nloops += priv_nloops; printf(" total nloops is now %d.\n", glob_nloops); } } printf("Total # loop iterations is %d\n", glob_nloops); return 0; }
You are instructed to print the numbers from 1 to n in the venerable puzzle FizzBuzz. Print ", though, if the number is divisible by 3 instead "izz". Print it if it is divisible by 5 "Buzz". Print it if it is divisible by 3 and 5 "izzBuzz". You are required to carry out this task using multiple threads in this problem.Implement a four-threaded multithreaded FizzBuzz implementation. One thread prints and checks the divisibility of three "izz". A different thread is in charge of the divisibility of 5 and printing "Buzz". Divisibility of 3 and 5 is handled by a third thread, which also prints " "izzBuzz". The computation is done by a fourth thread.
In this program, you manipulate a Table, having an array of doubles, which is shared between 3 threads DepositThread and 3 other threads RemoveThread. - DepositThread increments (by 1) the values of the array.- RemoveThread decrements (by 1) the values of the array.- Every DepositThread and RemoveThread has a thread name.- Before starting the incrementing or decrementing task, every thread has to introduce itself by printing a sentence as follows: THREAD thread-name is incrementing/decrementing the array... Example: "THREAD DepositTh-1 is incrementing the array..." - The table is initially filled by zeros. So, logically, at the end of threads’ job, the table values must be all zeros again. - The main thread waits till all other threads finish execution, and then it prints the resulting array elements.- Class Table is given below: Table - tab[] : double + Table()+ incTab() : void+ decTab() : void+ displayTab() : void Using java language with…
I have my code below and I am stuck at the last part which is the display of the thread that finished first and last. There are times when it give the correct output and sometimes it is not. How can it be fixed? The sample output is given below and the output I made. import java.util.Random;import java.util.Scanner; class prog1 implements Runnable { private String cName = new String(""); private int x; public int c1 = 0, c2 = 0, c3 = 0; // static array to store which thread closed first public static int [] order = new int[3]; // index of array private static int index = 0; public prog1 (String cName, int x){ this.cName = cName; this.x = x; } @Override public void run(){ Random r = new Random(); int randNum; for (int i = 1; i <= this.x; i++){ randNum = r.nextInt(x) + 1; if(i == this.x) { // put the number // get number from name's last character of thread…