COMP3000 Operating Systems F23: Tutorial 6 - Revision history

Abdou: /* C: Producer/Consumer with Shared Memory */

2023-10-25T01:09:18Z

C: Producer/Consumer with Shared Memory

← Older revision		Revision as of 01:09, 25 October 2023
Line 29:		Line 29:
	==C: Producer/Consumer with Shared Memory==		==C: Producer/Consumer with Shared Memory==
	<ol style="list-style-type:decimal">		<ol style="list-style-type:decimal">
	<li> Examine the source code of <tt>3000pc-rendezvous</tt>. Explain the following:		<li> Examine the source code of <code>3000pc-rendezvous</code>. Explain the following:
	<ol style="list-style-type:lower-alpha">		<ol style="list-style-type:lower-alpha">
	<li> What are a few ways that <tt>3000pc-rendezvous</tt> is different from <tt>3000pc-fifo</tt>? </li>		<li> What are a few ways that <code>3000pc-rendezvous</code> is different from <code>3000pc-fifo</code>? </li>
	<li> What does the call to <tt>mmap()</tt> on line 347 do (compared to our previous uses of <tt>mmap()</tt>)? <u>How</u> did you figure this out? </li>		<li> What does the call to <code>mmap()</code> on line 347 do (compared to our previous uses of <code>mmap()</code>)? <u>How</u> did you figure this out? </li>
	<li> How does the producer notify the consumer that the queue is no longer empty? </li>		<li> How does the producer notify the consumer that the queue is no longer empty? </li>
	<li> How does the consumer notify the producer that the queue is no longer full? </li>		<li> How does the consumer notify the producer that the queue is no longer full? </li>
Line 39:		Line 39:
	<li> What arguments can you provide to make the producer wait for the consumer? Hint: Check the size of the queue. </li>		<li> What arguments can you provide to make the producer wait for the consumer? Hint: Check the size of the queue. </li>
	<li> What arguments can you provide to make the consumer wait for the producer? (You can disregard the wait at the very beginning as the queue is initially empty) </li>		<li> What arguments can you provide to make the consumer wait for the producer? (You can disregard the wait at the very beginning as the queue is initially empty) </li>
	<li> Another student tells you that the difference between processes and threads is that processes never share memory, while threads do. Is this statement correct or incorrect? How can the behavior of <tt>3000pc-rendezvous</tt> help justify your answer? </li>		<li> Another student tells you that the difference between processes and threads is that processes never share memory, while threads do. Is this statement correct or incorrect? How can the behavior of <code>3000pc-rendezvous</code> help justify your answer? </li>
	<li> Change the calls to <tt>pthread_mutexattr_setpshared()</tt> and <tt>pthread_condattr_setpshared()</tt> (lines 293 and 298) to take 0 instead of 1. How does the behavior or <tt>3000pc-rendezvous</tt> change? Does anything break? </li>		<li> Change the calls to <code>pthread_mutexattr_setpshared()</code> and <code>pthread_condattr_setpshared()</code> (lines 293 and 298) to take 0 instead of 1. How does the behavior or <code>3000pc-rendezvous</code> change? Does anything break? </li>
	</ol>		</ol>

Abdou: /* B: Producer/Consumer with Pipes */

2023-10-25T01:08:23Z

B: Producer/Consumer with Pipes

← Older revision		Revision as of 01:08, 25 October 2023
Line 17:		Line 17:
	==B: Producer/Consumer with Pipes==		==B: Producer/Consumer with Pipes==
	<ol style="list-style-type:decimal">		<ol style="list-style-type:decimal">
	<li> Examine the source code of <tt>3000pc-fifo</tt>. Pay attention to the call to <tt>pipe(pipefd)</tt> on line 192 and make the connection with what has been discussed in the lecture (also look at the man page for <tt>pipe(2)</tt>). Explain the following:		<li> Examine the source code of <code>3000pc-fifo</code>. Pay attention to the call to <code>pipe(pipefd)</code> on line 192 and make the connection with what has been discussed in the lecture (also look at the man page for <code>pipe(2)</code>). Explain the following:
	<ol style="list-style-type:lower-alpha">		<ol style="list-style-type:lower-alpha">
	<li> How does the consumer receive words to consume? </li>		<li> How does the consumer receive words to consume? </li>
	<li> How does the producer generate and send words to the consumer? </li>		<li> How does the producer generate and send words to the consumer? </li>
	<li> Why is the call to <tt>srandom(time(NULL))</tt> on line 169 necessary? </li>		<li> Why is the call to <code>srandom(time(NULL))</code> on line 169 necessary? </li>
	</ol>		</ol>
	</li>		</li>
	<li> Replace the call to <tt>srandom(time(NULL))</tt> on line 169 with <tt>srandom(42)</tt>. What differences do you notice in <tt>3000pc-fifo</tt>'s behavior? </li>		<li> Replace the call to <code>srandom(time(NULL))</code> on line 169 with <code>srandom(42)</code>. What differences do you notice in <code>3000pc-fifo</code>'s behavior? </li>
	</ol>		</ol>

Abdou: /* A: Getting Started */

2023-10-25T01:07:51Z

A: Getting Started

← Older revision		Revision as of 01:07, 25 October 2023
Line 2:		Line 2:

	==A: Getting Started==		==A: Getting Started==
	Download [https://people.scs.carleton.ca/~~~lianyingzhao~~/comp3000/~~w23~~/tut6/3000pc.zip 3000pc.zip], unpack, and run <tt>make</tt> to compile <tt>3000pc-fifo</tt> and <tt>3000pc-rendezvous</tt>.		Download [https://people.scs.carleton.ca/~abdou/comp3000/f23/tut6/3000pc.zip 3000pc.zip], unpack, and run <code>make</code> to compile <code>3000pc-fifo</code> and <code>3000pc-rendezvous</code>.

	Try to take this opportunity to read and understand the two programs line by line.		Try to take this opportunity to read and understand the two programs line by line.
Line 12:		Line 12:

	# Run both programs with the same arguments of your choice. Do this a few times with different arguments. Do they behave the same way? Do you notice <u>any differences</u>? (again, no “correct” answers but just play with them and document your observations)		# Run both programs with the same arguments of your choice. Do this a few times with different arguments. Do they behave the same way? Do you notice <u>any differences</u>? (again, no “correct” answers but just play with them and document your observations)
	# Repeat the above experiment, this time running each program under <tt>strace</tt> (with the <tt>-f</tt> flag to trace children too). Do you notice any difference in the system calls each program makes? Remember to ignore the lines before <tt>main()</tt> that might be distracting, e.g., start looking around and after the <tt>clone()</tt> system call.		# Repeat the above experiment, this time running each program under <code>strace</code> (with the <code>-f</code> flag to trace children too). Do you notice any difference in the system calls each program makes? Remember to ignore the lines before <code>main()</code> that might be distracting, e.g., start looking around and after the <code>clone()</code> system call.
	# You can see there is "<tt>#define QUEUESIZE 32</tt>" in both programs. Are they actually used? <u>Why (not)</u>?		# You can see there is "<code>#define QUEUESIZE 32</code>" in both programs. Are they actually used? <u>Why (not)</u>?

	==B: Producer/Consumer with Pipes==		==B: Producer/Consumer with Pipes==

Abdou: /* General Instructions (same for all tutorials) */

2023-10-25T01:06:17Z

General Instructions (same for all tutorials)

← Older revision		Revision as of 01:06, 25 October 2023
Line 1:		Line 1:
	In this tutorial you will be learning about two implementations of the [https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem producer-consumer problem], a classic example of a concurrency problem. The [http://pages.cs.wisc.edu/~remzi/OSTEP/ class textbook] covers concurrency in great detail in Chapters 25-34, and the producer-consumer problem is covered in [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf Chapter 30 (Condition Variables)] and [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf Chapter 31 (Semaphores)]. While you can look at this part of the textbook, note that we will not be covering this material in the same level of detail, as should be clear from this tutorial.		In this tutorial you will be learning about two implementations of the [https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem producer-consumer problem], a classic example of a concurrency problem. The [http://pages.cs.wisc.edu/~remzi/OSTEP/ class textbook] covers concurrency in great detail in Chapters 25-34, and the producer-consumer problem is covered in [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf Chapter 30 (Condition Variables)] and [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf Chapter 31 (Semaphores)]. While you can look at this part of the textbook, note that we will not be covering this material in the same level of detail, as should be clear from this tutorial.

	~~==General Instructions (same for all tutorials)==~~

	~~<div class="mw-collapsible mw-collapsed">~~
	~~Click on Expand to view.~~
	~~<div class="mw-collapsible-content">~~
	Tutorials are graded based on participation and effort ('''so no need to struggle to have the “correct” answers — what matters is the attempts and sufficient thinking reflected in your answers'''), but you should still turn in your work. Submit your answers on Brightspace as a single text file named "<username>-comp3000-t<n>.txt" (where username is your MyCarletonOne username and n is the tutorial number). The first four lines of this file should be "COMP 3000 Tutorial <n>", your name, student number, and the date of submission. Your submitted answers must at least respond to all the items in the '''Tasks/Questions''' section.

	The deadline is usually four days after the tutorial date (see the actual deadline on the submission entry). Note that the submission entry is enforced by the system, so you may fail to get the effort marks even if it is one minute past the deadline.

	You should also check in with your assigned TA (in person or by responding to a poll if online). Your TA will be your first point of contact when you have questions or encounter any issues during the tutorial session.

	~~You get 1.5 marks for submitting answers that shows your effort and 0.5 for checking in, making this tutorial worth 2 points total.~~

	~~Read through the instructions before starting your work to get an overall picture. When source files are needed, you can download them by clicking on the hyperlink.~~
	~~</div>~~
	~~</div>~~

	==A: Getting Started==		==A: Getting Started==

Abdou: Created page with "In this tutorial you will be learning about two implementations of the [https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem producer-consumer problem], a classic example of a concurrency problem. The [http://pages.cs.wisc.edu/~remzi/OSTEP/ class textbook] covers concurrency in great detail in Chapters 25-34, and the producer-consumer problem is covered in [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf Chapter 30 (Condition Variables)] and [http://pages..."

2023-10-25T01:05:40Z

Created page with "In this tutorial you will be learning about two implementations of the [https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem producer-consumer problem], a classic example of a concurrency problem. The [http://pages.cs.wisc.edu/~remzi/OSTEP/ class textbook] covers concurrency in great detail in Chapters 25-34, and the producer-consumer problem is covered in [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf Chapter 30 (Condition Variables)] and [http://pages..."

New page

In this tutorial you will be learning about two implementations of the [https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem producer-consumer problem], a classic example of a concurrency problem. The [http://pages.cs.wisc.edu/~remzi/OSTEP/ class textbook] covers concurrency in great detail in Chapters 25-34, and the producer-consumer problem is covered in [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf Chapter 30 (Condition Variables)] and [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf Chapter 31 (Semaphores)]. While you can look at this part of the textbook, note that we will not be covering this material in the same level of detail, as should be clear from this tutorial.

==General Instructions (same for all tutorials)==

<div class="mw-collapsible mw-collapsed">
Click on Expand to view.
<div class="mw-collapsible-content">
Tutorials are graded based on participation and effort ('''so no need to struggle to have the “correct” answers — what matters is the attempts and sufficient thinking reflected in your answers'''), but you should still turn in your work. Submit your answers on Brightspace as a single text file named "<username>-comp3000-t<n>.txt" (where username is your MyCarletonOne username and n is the tutorial number). The first four lines of this file should be "COMP 3000 Tutorial <n>", your name, student number, and the date of submission. Your submitted answers must at least respond to all the items in the '''Tasks/Questions''' section.

The deadline is usually four days after the tutorial date (see the actual deadline on the submission entry). Note that the submission entry is enforced by the system, so you may fail to get the effort marks even if it is one minute past the deadline.

You should also check in with your assigned TA (in person or by responding to a poll if online). Your TA will be your first point of contact when you have questions or encounter any issues during the tutorial session.

You get 1.5 marks for submitting answers that shows your effort and 0.5 for checking in, making this tutorial worth 2 points total.

Read through the instructions before starting your work to get an overall picture. When source files are needed, you can download them by clicking on the hyperlink.
</div>
</div>

==A: Getting Started==
Download [https://people.scs.carleton.ca/~lianyingzhao/comp3000/w23/tut6/3000pc.zip 3000pc.zip], unpack, and run <tt>make</tt> to compile <tt>3000pc-fifo</tt> and <tt>3000pc-rendezvous</tt>.

Try to take this opportunity to read and understand the two programs line by line.

:: Note that these programs take 3 arguments each:
::* The number of events to process
::* The number of events to produce before the producer sleeps for 1 second
::* The number of events to consume before the consumer sleeps for 1 second

# Run both programs with the same arguments of your choice. Do this a few times with different arguments. Do they behave the same way? Do you notice <u>any differences</u>? (again, no “correct” answers but just play with them and document your observations)
# Repeat the above experiment, this time running each program under <tt>strace</tt> (with the <tt>-f</tt> flag to trace children too). Do you notice any difference in the system calls each program makes? Remember to ignore the lines before <tt>main()</tt> that might be distracting, e.g., start looking around and after the <tt>clone()</tt> system call.
# You can see there is "<tt>#define QUEUESIZE 32</tt>" in both programs. Are they actually used? <u>Why (not)</u>?

==B: Producer/Consumer with Pipes==
<ol style="list-style-type:decimal">
<li> Examine the source code of <tt>3000pc-fifo</tt>. Pay attention to the call to <tt>pipe(pipefd)</tt> on line 192 and make the connection with what has been discussed in the lecture (also look at the man page for <tt>pipe(2)</tt>). Explain the following:
<ol style="list-style-type:lower-alpha">
<li> How does the consumer receive words to consume? </li>
<li> How does the producer generate and send words to the consumer? </li>
<li> Why is the call to <tt>srandom(time(NULL))</tt> on line 169 necessary? </li>
</ol>
</li>
<li> Replace the call to <tt>srandom(time(NULL))</tt> on line 169 with <tt>srandom(42)</tt>. What differences do you notice in <tt>3000pc-fifo</tt>'s behavior? </li>
</ol>

==C: Producer/Consumer with Shared Memory==
<ol style="list-style-type:decimal">
<li> Examine the source code of <tt>3000pc-rendezvous</tt>. Explain the following:
<ol style="list-style-type:lower-alpha">
<li> What are a few ways that <tt>3000pc-rendezvous</tt> is different from <tt>3000pc-fifo</tt>? </li>
<li> What does the call to <tt>mmap()</tt> on line 347 do (compared to our previous uses of <tt>mmap()</tt>)? <u>How</u> did you figure this out? </li>
<li> How does the producer notify the consumer that the queue is no longer empty? </li>
<li> How does the consumer notify the producer that the queue is no longer full? </li>
</ol>
</li>
<li> What arguments can you provide to make the producer wait for the consumer? Hint: Check the size of the queue. </li>
<li> What arguments can you provide to make the consumer wait for the producer? (You can disregard the wait at the very beginning as the queue is initially empty) </li>
<li> Another student tells you that the difference between processes and threads is that processes never share memory, while threads do. Is this statement correct or incorrect? How can the behavior of <tt>3000pc-rendezvous</tt> help justify your answer? </li>
<li> Change the calls to <tt>pthread_mutexattr_setpshared()</tt> and <tt>pthread_condattr_setpshared()</tt> (lines 293 and 298) to take 0 instead of 1. How does the behavior or <tt>3000pc-rendezvous</tt> change? Does anything break? </li>
</ol>