DT 8025 2016 Practical 2 - Revision history

Ceres at 07:25, 7 October 2016

2016-10-07T07:25:20Z

Ceres at 07:24, 4 October 2016

2016-10-04T07:24:02Z

Ceres at 07:09, 4 October 2016

2016-10-04T07:09:42Z

Ceres at 07:05, 4 October 2016

2016-10-04T07:05:31Z

Ceres at 19:13, 3 October 2016

2016-10-03T19:13:58Z

Ceres at 19:10, 3 October 2016

2016-10-03T19:10:58Z

Ceres at 19:09, 3 October 2016

2016-10-03T19:09:38Z

Ceres at 19:09, 3 October 2016

2016-10-03T19:09:16Z

Ceres at 19:08, 3 October 2016

2016-10-03T19:08:25Z

Ceres at 18:36, 3 October 2016

2016-10-03T18:36:58Z

@@ Line 54: / Line 54: @@
 Each philosopher process is responsible for updating the digit of the corresponding philosopher on the display as well as both forks whenever it makes any change to them.
+We assume that the program starts in a blocking state (each philosopher has picked the right hand side fork).
-Implement the protocol in a way that it is deadlock free (using yieldtask() properly) and test your program by providing unit tests.
+Implement the protocol in a way that the deadlock situations can be resolved (using yieldtask() properly) and test your program by providing unit tests.
 ===[[DT_8025_2016 |Back to Course Page]]===

@@ Line 13: / Line 13: @@
 For each function in the code, you need to write evidence of test-driven development, both in terms of comments (description, pre- and post-condition and properties) and unit testing test suites (e.g., in CUnit, see below).
 To show the successful execution of your test suite, also include the XML file resulting from its execution.
-Include a report document (preferably with PDF format) which explains the details about the implementation of each part of the assignment (including details of the implemented functions and what they do).
+Include a document (preferably with PDF format) which explains the details about the implementation of each part of the assignment (including details of the implemented functions and what they do).
 === Part 1: Yield and Taskswitch ===
-Download the  [[media:DT8025_2016_libtask.zip| Libtask library]]  and run the sample program primes on the Raspberry Pi. This is a simple example with only one thread to execute. There is no way of switching context because there is no invocation to taskyield() which is a function in the library used for changing control between threads. Hence, to be able to switch the control between threads using this library you need to implement two functions. The first function is:
+Download the  [[media:DT8025_2016_libtask.zip| Libtask library]]  and run the sample program primes on the Raspberry Pi. This is a simple example with only one thread to execute. There is no way of switching context because there is no invocation to taskyield() which is a function in the library used for switching control between threads. Hence, to be able to switch the control between threads using this library you need to implement two functions. The first function is:
   taskyield()
-This is the main function used for cooperative control switch. Implement the function such that it
+This is the main function used for cooperative control switch between threads. Implement the function such that it
 *enqueues the current thread in the ready queue,
-*set the state of the task as "yield",
+*set the state of the thread as "yield",
 * pick the first element in the queue, dequeue it and dispatch it by switching the context of two tasks
-In order to switch the context of two tasks you need to implement another function in the library, namely:
+In order to switch the context of two threads you need to implement another function in the library, namely:
@@ Line 33: / Line 33: @@
-This function is used to switch the context between two tasks by calling the contextswitch() function in libtask.
+This function is used to switch the context of two threads by calling the contextswitch() function in libtask.
 Complete the body of these two functions in the library and test your implementation using unit tests.
 === Part 2: Concurrency and Dining Philosophers ===
-This part of the assignment consists of implementing a sample of dining philosophers. In this protocol a group of philosophers are siting around a table and there is a fork placed between each two philosophers. [https://www.youtube.com/watch?v=92WHN-pAFCs  A Clip about the Halting Problem]
+This part of the assignment consists of implementing a sample of dining philosophers (you can find a brief description of the protocol [https://en.wikipedia.org/wiki/Dining_philosophers_problem  here]). In this protocol a group of philosophers are siting around a table and there is a fork placed between each two philosophers. Each philosopher alternates between eating and thinking by going through a set of states. A philosopher can enter the eating state by obtaining the two forks on both sides.
 The configuration of the protocol with two philosophers and forks can be displayed on the display (or PiFace) by an integer comprising 4 digits:
@@ Line 51: / Line 51: @@
   void phil2()
 The state of forks and philosophers are implemented as global integer variables to represent the behavior of philosophers (first thinking, then becoming hungry and trying to grab one fork, grabbing a fork when available, then trying to grab the other fork, then grabbing the other fork and eating and finally,  going back to the thinking state).
-Note that the access to the forks (global variables) should be surrounded by a locks (there are functions in the libtask to manipulate locks).
+Note that the access to the forks (global variables) should be surrounded by locks (there are functions in the libtask for manipulating locks).
 Each philosopher process is responsible for updating the digit of the corresponding philosopher on the display as well as both forks whenever it makes any change to them.

@@ Line 38: / Line 38: @@
 === Part 2: Concurrency and Dining Philosophers ===
-This part of the assignment consists of implementing a sample of dining philosophers. In this protocol a group of philosophers are siting around a table and there is a fork placed between each two philosophers. The configuration of the protocol with two philosophers and forks can be displayed on the display (or PiFace) by an integer comprising 4 digits:
+This part of the assignment consists of implementing a sample of dining philosophers. In this protocol a group of philosophers are siting around a table and there is a fork placed between each two philosophers. [https://www.youtube.com/watch?v=92WHN-pAFCs  A Clip about the Halting Problem]
 * the first and the third digits represent the state of the first and the second forks, respectively; value 0 (for each fork) means free and 1 means taken,
@@ Line 55: / Line 56: @@
 Implement the protocol in a way that it is deadlock free (using yieldtask() properly) and test your program by providing unit tests.

@@ Line 17: / Line 17: @@
 === Part 1: Yield and Taskswitch ===
-Download the Libtask library and run the sample program primes on the Raspberry Pi. This is a simple example with only one thread to execute. There is no way of switching context because there is no invocation to taskyield() which is a function in the library used for changing control between threads. Hence, to be able to switch the control between threads using this library you need to implement two functions. The first function is:
+Download the  [[media:DT8025_2016_libtask.zip| Libtask library]]  and run the sample program primes on the Raspberry Pi. This is a simple example with only one thread to execute. There is no way of switching context because there is no invocation to taskyield() which is a function in the library used for changing control between threads. Hence, to be able to switch the control between threads using this library you need to implement two functions. The first function is:
   taskyield()

@@ Line 49: / Line 49: @@
   void phil1()
   void phil2()
-to represent the behavior of philosophers (first thinking, then becoming hungry and trying to grab one fork, grabbing a fork when available, then trying to grab the other fork, then grabbing the other fork and eating and finally,  going back to the thinking state).
+The state of forks and philosophers are implemented as global integer variables to represent the behavior of philosophers (first thinking, then becoming hungry and trying to grab one fork, grabbing a fork when available, then trying to grab the other fork, then grabbing the other fork and eating and finally,  going back to the thinking state).
-Note that the access to the forks (global variables) should be surrounded by a locks.
+Note that the access to the forks (global variables) should be surrounded by a locks (there are functions in the libtask to manipulate locks).
 Each philosopher process is responsible for updating the digit of the corresponding philosopher on the display as well as both forks whenever it makes any change to them.
 Implement the protocol in a way that it is deadlock free (using yieldtask() properly) and test your program by providing unit tests.

@@ Line 46: / Line 46: @@
 For example, 1 4 1 1 denotes the situation where the first philosopher is eating with two forks and the second philosopher is hungry and trying to get hold of one fork.
-Implement the protocol with two philosophers and forks by implementing the two following functions.
+Implement the protocol with two philosophers and forks by implementing following functions.
   void phil1()
   void phil2()

← Older revision		Revision as of 19:09, 3 October 2016
Line 30:		Line 30:


−	taskswitch()	+	taskswitch()

← Older revision		Revision as of 18:36, 3 October 2016
Line 1:		Line 1:
−	~~jdsfjdshjf~~	+	== Objectives ==
		+
		+	There are three objectives for this practical:
		+
		+	* Learn about and implement the basic ingredients for concurrency,
		+	* Implement the mutual exclusion primitives,
		+	* Use them in implementing a simple access control protocol
		+
		+	== Instructions ==
		+
		+	Submit a single .zip file on blackboard with separate folders, each containing the solutions to the below-specified parts.
		+
		+	For each function in the code, you need to write evidence of test-driven development, both in terms of comments (description, pre- and post-condition and properties) and unit testing test suites (e.g., in CUnit, see below).
		+	To show the successful execution of your test suite, also include the XML file resulting from its execution.
		+	Include a report document (preferably with PDF format) which explains the details about the implementation of each part of the assignment (including details of the implemented functions and what they do).
		+
		+	=== Part 1: Yield and Context ===
		+
		+	Download the Libtask library and run the sample program primes on the Raspberry Pi. This is a simple example with only one thread to execute. There is no way of switching context because there is no invocation to taskyield() which is a function in the library used for changing control between threads. Hence, to be able to switch the control between threads using this library you need to implement two functions. The first function is:
		+
		+	taskyield()
		+
		+	This is the main function used for cooperative control switch. Implement the function such that: