Write a solution for the producer/consumer problem using processes instead of threads. Refer to the solution worked out in the demo and make sure you fully understand what is going on there before beginning this one (source file is attached to this assignment). Turn in all code and a text file called README containing instructions for building and running your programs. All programs must compile and run on os.cs.siue.edu. Descriptions of functions listed below in bold can be found in the man pages (e.g. man fork), though sometimes you may need to specify the correct section of the manual to get the correct page (e.g. man 3 printf). Approach the homework in phases and incrementally grow your solution: start with process creation (e.g. if there's one producer and one consumer specified, one process -the parent- will fork two others, a producer program and a consumer program), then move on to shared memory stuff (making sure that the children can read what the parent is placing in there), and only then finish up the producer/consumer portion (pretty much the same as the threaded version). Use the following functions for process creation, etc: fork - create a new process execlp - replace current process image with a new process image (i.e. execute a file) waitpid - allows parent to wait for a child with specified pid Use the following functions for sharing stuff between processes: shm_open - create a named chunk of shared memory ftruncate - to change the size of the named chunk of shared memory mmap - to map the shared memory chunk into current process' address space Example: Let's say you want to share a struct, like: typedef struct shared{ int some_int_to_share; int some_other_int_to_share; ... }shared; In the parent process (the one that starts everything): int fd = shm_open("prodconshare", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); ftruncate(fd, sizeof(shared)); shared* sharedstruct = mmap(NULL, sizeof(shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); In the child process it is similar, but the child process would not create the named chunk if it doesn't exist and the child process has no need to resize the chunk (so, no ftruncate): int fd = shm_open("prodconshare", O_RDWR, S_IRUSR | S_IWUSR); shared* sharedstruct = mmap(NULL, sizeof(shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Use the following functions to synchronize the producers and consumers: sem_init - initialize a semaphore sem_wait - decrement a semaphore sem_post - increment a semaphore (remember that decrementing a semaphore below zero will put the calling process to sleep and sem_post will have to be called by another process to wake it up. You might think about stuffing some semaphores into the shared memory, using a struct to arrange the shared memory chunk's contents.) The producers can exit when they've produced their whole string, e.g. "hello world". For simplicity, the consumers may run indefinitely and be terminated with ctrl+c. Other useful functions: malloc - allocate memory sizeof - get the size of things printf - print stuff perror - print error stuff

CIS22B LinC Assignment 1: Application of Integration in Physics

You are a fledgling engineer who just started at BP and are tasked with finding out how much energy is needed to extract oil at an offshore oil rig. Your team has figured out how much force the extraction machines can use to draw up a kilogram of oil, but the managers would like to know how high the extractor can pull the oil up. Your task is to create a program that can calculate the work done on the oil being pulled up from the ground.

Work: o Energy can be measured through the "work" done on objects and fluids. o Work is calculated by integrating the function that defines force: = ()

o Where: o W is the work done in total o F(x) is the equation for the force done on a kilogram of oil o a is the starting height oil will be pulled from o b is the end height the oil will be pulled to. This value will always be 50 meters. Force Equation: o The force needed to lift a certain amount of oil is given as follows: ()=402 +10+300 You will need to integrate this function and use the result to calculate work. The Assignment: o Write a C++ program that can calculate the work done on the oil by the extractor. o The program should follow these steps: Read in the values from the included heights.txt file into an array. The values in the file are starting heights the oil will be pulled up from. There are five values to be read in. Your arrays should all be of size 5. If the file was read successfully, have the rest of the program run in main. Otherwise, output an error message and exit the program. Sort the array of starting heights using a sorting algorithm of your choice. Specify which algorithm you are using in a comment before your sorting function implementation. For every starting height in the sorted array, calculate the work Remember that the end height is always 50. The starting heights are the values in the sorted array. The work calculated should also be stored into a separate array. Each entry in the work array should be in the same relative index as its starting height ex: the starting height at index 0 in its array should have a work value stored in the work array at index 0.

Write each starting height and the work done on that oil, to an output file called work_results.txt. The height and work amounts should be separated by a space. Each entry of oil and work amount should be on their own line.

Functions Needed: o bool readHeightsFromFile(int heightsArr[], const int ARR_SIZE) This function should read in the starting height values from the input file heights.txt. The values are should be stored into heightsArr. Make sure to do proper checking for if the input file was opened. Remember to close the file after you are done reading from it. Return true or false, depending on if the file could be opened or not. o void sortArray(int arr[], const int ARR_SIZE) This function should sort the array in ascending order. Use any sorting algorithm you learned in CIS22A. Make sure to put a comment before this function specifying which sorting algorithm you use. o double calcWork(int lowerBound, int upperBound) This function calculates work as the indefinite integral of the Force equation. Do the antiderivative by hand first, then implement the equation, substituting in the values for the upper and lower bounds of integration. Return the result of the work calculation. It should be stored into an array of work results, at the same relative index as the starting height used for the lower bound. o void writeResultsToFile(int heightsArr[], int workArr[], const int ARR_SIZE) This function writes the starting heights and work calculated to an output file work_results.txt. The starting height and its resulting work should be written on the same line, separated by a single space. Each pair of starting height and resulting work should be on their own individual lines.

height(1).txt

The sample output expected in the file:

-25 1906875 -10 1710000 0 1694166 3 1692861 10 1677333