SUBJECT: SOFTWARE ENGINEERINGRead the following code carefully and perform the following tasks: Draw Control Flow Graph for the given codeHighlight all regions in the flow graph separatelyUsing cyclometic complexity formula, calculate number of basis pathShow path of each basis path test #include #include int value0;void *runner (void *param);/* the thread* /int main (int argc,char *argv[]){int pid;pthread.t tid;pthread attr.t attr;pidfork ();if (pidpthread attr.init (&attr);pthread.create (&tid, &attr,runner,NULL);pthread.join(tid,NULL);printf(" CHILD: value}else if (pid >wait (NULL);printf (" PARENT: value}0) {/* child process* /==%d",value); /* LINE C */0) {/* parent process* /%d", value); /*LINE P* /void *runner (void *param) {value =5;pthread exit (0);

According to the question, we need to: Draw Control Flow Graph for the given code Highlight all…

Answered: Draw Control Flow Graph for the given…

Draw Control Flow Graph for the given code Highlight all regions in the flow graph separately Using cyclometic complexity formula, calculate number of basis path Show path of each basis path test

Systems Architecture

7th Edition

ISBN:9781305080195

Author:Stephen D. Burd

Publisher:Stephen D. Burd

Chapter3: Data Representation

Section: Chapter Questions

Problem 13RQ: How is an array stored in main memory? How is a linked list stored in main memory? What are their...

See similar textbooks

Similar questions

Rewrite method inserthelp() to take advantage of the modified BSTNode in which a pointer can be either a regular pointer or a thread. Modify method printhelp() to work with threaded nodes. Add method printInorder() to do an inorder printing of your tree without the use of recursion. Add printReverse() to do a reverse order printing of your tree without resorting to recursion. You may add private helper methods as needed to make modifying or creating the methods above easier.
Debug this code in C so it runs. Here it is. Code: #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <pthread.h> void multiThreads(); void* threadFunction(void* vargp); void main(){ multiThreads(); return 0; } void multiThreads(){ int SIZE = 5; int i; int error; pthread_t tid[SIZE]; while(i < SIZE){ error = pthread_create(&(tid[i]), NULL, &threadFunction, (void*)&(tid[i])); if(error != 0){ printf("\nThread can't be created : [%s] \n Press 'Enter’ to continue...", strerror(error)); } i++; }//end while while(i < SIZE){ pthread_join(tid[i], NULL); i++; } } void* threadFunction(void* vargp){ int LOOP = 5; int i; int* myid = (int*)vargp; printf("\n-----------------------------\n"); printf("\nThread %i has started\n", myid); printf("\n-----------------------------\n"); for(i = 0; i <= LOOP; i++){ printf("\nThread ID %i is printing…
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…
The main thread of a Java program can generate additional threads. true or false It is possible to implement an unbounded queue using an array-based approach. true or false
Convert this C++ program into C #include <iostream> #include <pthread.h> // size of array #define MAX 100 // maximum number of threads #define MAX_THREAD 4 using namespace std; int a[] = { 1, 5, 7, 10, 12, 14, 15, 18, 20, 22, 25, 27, 30, 64, 110, 220 }; int sum[4] = { 0 }; int part = 0; void* sum_array(void* arg) { // Each thread computes sum of 1/4th of array int thread_part = part++; for (int i = thread_part * (MAX / 4); i < (thread_part + 1) * (MAX / 4); i++) sum[thread_part] += a[i]; } int main() { pthread_t threads[MAX_THREAD]; // Creating 4 threads for (int i = 0; i < MAX_THREAD; i++) pthread_create(&threads[i], NULL, sum_array, (void*)NULL); // joining 4 threads i.e. waiting for all 4 threads to complete for (int i = 0; i < MAX_THREAD; i++) pthread_join(threads[i], NULL); // adding sum of all 4 parts int total_sum = 0; for (int i = 0; i < MAX_THREAD; i++)…
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…
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.
For this assignment you need to write a parallel program in C++ using OpenMP for vector addition. Assume A, B, C are three vectors of equal length. The program will add the corresponding elements of vectors A and B and will store the sum in the corresponding elements in vector C (in other words C[i] = A[i] + B[i]). Every thread should execute approximately equal number of loop iterations. The only OpenMP directive you are allowed to use is: #pragma omp parallel num_threads(no of threads) The program should take n and the number of threads to use as command line arguments: ./parallel_vector_addition Where n is the length of the vectors and threads is the number of threads to be created. Pseudocode for Assignment mystart = myid*n/p; // starting index for the individual thread myend = mystart+n/p; // ending index for the individual thread for (i = mystart; i < myend; i++) // each thread computes local sum do vector addition // and later all local sums combined. As an input vector A,…
1. In a linked stack the bottom of the stack is in the beginning of the list and the top of the stack is at the end of the list. 2. In the worst case a sequential search of an array with N elements is O(N). 3. In the best case, a sequential search of an array with 1,000 elements requires this many comparisons: ________________. 4. Java programmers can define their own exception classes. A. True B. False 5. If a recursive method does not have a base case: A. a syntax error is identified.B. an exception will be thrown. C. it will operate more efficiently.D. it will run forever.
This is what i have for array stack to far: from exceptions import Emptyclass ArrayStack:"""LIFO Stack implementation using a Python list as underlying storage."""def __init__(self):"""Create an empty stack."""self._data = [] # nonpublic list instancedef __len__(self):"""Return the number of elements in the stack."""return len(self._data)def is_empty(self):"""Return True if the stack is empty."""return len(self._data) == 0def push(self, e):"""Add element e to the top of the stack."""self._data.append(e) # new item stored at end of listdef top(self):"""Return (but do not remove) the element at the top of the stack.Raise Empty exception if the stack is empty."""if self.is_empty():raise Empty('Stack is empty')return self._data[-1] # the last item in the listdef pop(self):"""Remove and return the element from the top of the stack (i.e., LIFO).Raise Empty exception if the stack is empty."""if self.is_empty():raise Empty('Stack is empty')return self._data.pop() # remove last item from…
This is Java. Combine the “Stacks and Queues starter files”. Inside of main(), write the Java code to meet the following requirements: Allow the user to enter 10 integers from the keyboard Store odd # in evenStack (I know, it says put odd# in even stack) Store even # in oddQueue (I know, it says put even# in odd queue) Traverse the evenStack, display each element and move it to a tempQueue Traverse the oddQueue, display each element and move it to the evenStack Traverse the tempQueue and move each element in to the oddQueue This is Java.
1. For the code below, draw a picture of the program stack when the function partition() is called the first time. You only have to draw the part of the stack for quicksort() and partition(). # extracted from suquant's reply at # https://stackoverflow.com/questions/18262306/quicksort-with-python def partition(array, begin, end): pivot = begin for i in range(begin+1, end+1): if array[i] <= array[begin]: pivot += 1 array[i], array[pivot] = array[pivot], array[i] array[pivot], array[begin] = array[begin], array[pivot] return pivot def quicksort(array, begin, end): if begin >= end: return pivot = partition(array, begin, end) quicksort(array, begin, pivot-1) quicksort(array, pivot+1, end) # added calling code if __name__ == "__main__": mylist = [8, 2, 17, 4, 12] quicksort(mylist, 0, 4)