Tutorial - Shared Memory - Revision history

Polas: 11 revisions imported

2019-04-15T15:44:59Z

11 revisions imported

Polas: /* Further communication */

2016-10-18T12:41:45Z

‎Further communication

Polas: /* Limits of communication */

2016-10-18T12:33:55Z

‎Limits of communication

Polas: /* Single to single */

2016-10-18T12:10:04Z

‎Single to single

Polas: /* Further communication */

2016-10-18T12:09:10Z

‎Further communication

Polas at 18:28, 19 January 2013

2013-01-19T18:28:14Z

Polas at 18:26, 19 January 2013

2013-01-19T18:26:58Z

Polas at 12:00, 17 January 2013

2013-01-17T12:00:53Z

Polas at 12:00, 17 January 2013

2013-01-17T12:00:23Z

Polas at 11:55, 17 January 2013

2013-01-17T11:55:42Z

@@ Line 60: / Line 60: @@
   function void main() {
-    var a:Int::allocated[multiple[commgroup[0,2]]];
+   var a:Int::allocated[multiple[commgroup[0,2]]];
-    proc 1 {
+   var b:Int::allocated[single[on[1]]];
-       a:=2;
+   group 0, 2 {
-    };
+      a:=2;
-    sync a;
+      b:=a;
-    group 0, 2 {
+   };
-       print(itostring(a)+"\n");
+   sync;
-    };
+   proc 1 {
   };
-The same thing will happen with [[Commgroup|communication groups]] too compile and run the following code, you will see that process one has written the value ''2'' into the memory of variable ''a'' which is held on processes zero and two.
+The above illustrates a  [[Commgroup|communication group]], as this has to be provided with [[Multiple]] the variable ''a'' is private to each process that it is allocated on.  Here processes zero and two update their own (local) version of ''a'' and then remotely write to variable ''b'' held on process one, both processes will send values over but as these are the same then there is no conflict. [[Sync|synchronisation]] is used to complete the RMA and ensure process one awaits updates to its ''b'' which it then displays.
 == Single to single ==

@@ Line 99: / Line 99: @@
 == Limits of communication ==
-Currently all communication is based upon assignment, to illustrate this look at the following code
+Currently all variables declared multiple (including communication groups) should be considered private, it is only variables declared single which can be accessed by another process.
 [[Category:Tutorials|Shared Memory]]

@@ Line 89: / Line 89: @@
         a:=b;
      };
-     //sync a;
+     //sync;
      group processOneAllocation {
         print(itostring(a)+"\n");

@@ Line 45: / Line 45: @@
      proc 0 {
         a:=1;
      };
-     sync b;
+     sync ;
      proc 1 {
         print(itostring(b)+"\n");
      };
   };
-The code snippet above is similar to the first one but with some important differences. We are declaring two variables; the first, ''a'', is held on process zero only whereas the second, ''b'', is allocated to all processes. Process zero then alone (via the [[Proc|proc]] statement will modify ''a'' locally (as it is held there) and then assign ''b'' to be the value of ''a''. We then [[Sync|synchronise]] based upon variable ''b'' and process one will display its value of ''b''. Stepping back a moment, what we are basically doing here is assigning a value to a variable allocated on all processes from one allocated on a single process. The result is that process zero will write the value of variable ''a'' into ''b'' on all processes (it is a broadcast.) If you remove the [[Sync|sync]] statement on line 11 then you will see that instead of displaying the value ''1'', ''0'' is displayed (the default [[Int]] initialisation value.) This is because synchronisation must occur to update this remote value on process one from process zero.
+The code snippet above is similar to the first one but with some important differences. We are declaring two variables; the first, ''a'', is held on process zero only whereas the second, ''b'', is allocated to all processes. Process zero then alone (via the [[Proc|proc]] statement will modify ''a'' locally (as it is held there). We then [[Sync|synchronise]] all processes to ensure process zero has updated ''a'' and then process one will obtain the value of ''a'' from process zero and pop this into its own ''b'', it then completes all operations involving variable ''a'' and displays its value of ''b''. Stepping back a moment, what we are basically doing here is getting some remote data and copying this into a local variable, the result is that the value held by process zero in ''a'' will be retrieved into ''b'' on process one. If you remove the [[Sync|sync]] statement on line 10 then you might see that instead of displaying the value ''1'', ''0'' is displayed (the default [[Int]] initialisation value.) This is because synchronisation must occur to ensure process zero has update ''a'' before process one reads from it, equally the last synchronisation statement completes RMA and if you remove this then likely the value in ''b'' will not have updated.
   #include <io>
@@ Line 69: / Line 70: @@
   };
 The same thing will happen with [[Commgroup|communication groups]] too compile and run the following code, you will see that process one has written the value ''2'' into the memory of variable ''a'' which is held on processes zero and two.
 == Single to single ==

← Older revision		Revision as of 18:28, 19 January 2013
Line 1:		Line 1:
−	<metadesc>Tutorial describing basic, shared remote memory, communication Mesham</metadesc>	+	<metadesc>Tutorial describing basic, shared remote memory, communication in Mesham</metadesc>
	'''Tutorial number five''' - [[Tutorial_-_Parallel Constructs\|prev]] :: [[Tutorial_-_Parallel Types\|next]]		'''Tutorial number five''' - [[Tutorial_-_Parallel Constructs\|prev]] :: [[Tutorial_-_Parallel Types\|next]]

← Older revision	Revision as of 15:44, 15 April 2019
(No difference)

← Older revision		Revision as of 18:26, 19 January 2013
Line 1:		Line 1:
		+	<metadesc>Tutorial describing basic, shared remote memory, communication Mesham</metadesc>
		+	'''Tutorial number five''' - [[Tutorial_-_Parallel Constructs\|prev]] :: [[Tutorial_-_Parallel Types\|next]]
		+
	== Introduction ==		== Introduction ==

← Older revision		Revision as of 12:00, 17 January 2013
Line 109:		Line 109:

	If we compile this then we will get the error message ''Assignment must be visible to process 1'' which is because, as communication is assignment driven, process one (which contains ''a'') must drive this assignment and communication. To fix this you could change from process zero to process one doing the assignment at line 8 which would enable this code to compile correctly. It is planned in the future to extend the compiler to support this pull (as well as push) remote memory mechanism.		If we compile this then we will get the error message ''Assignment must be visible to process 1'' which is because, as communication is assignment driven, process one (which contains ''a'') must drive this assignment and communication. To fix this you could change from process zero to process one doing the assignment at line 8 which would enable this code to compile correctly. It is planned in the future to extend the compiler to support this pull (as well as push) remote memory mechanism.
		+	[[Category:Tutorials\|Shared Memory]]

← Older revision		Revision as of 12:00, 17 January 2013
Line 94:		Line 94:

	== Limits of communication ==		== Limits of communication ==
		+
		+	Currently all communication is based upon assignment, to illustrate this look at the following code
		+
		+	#include <io>
		+	#include <string>
		+
		+	function void main() {
		+	var a:Int::allocated[single[on[1]]];
		+	var b:Int;
		+	proc 0 {
		+	b:=a;
		+	};
		+	};
		+
		+	If we compile this then we will get the error message ''Assignment must be visible to process 1'' which is because, as communication is assignment driven, process one (which contains ''a'') must drive this assignment and communication. To fix this you could change from process zero to process one doing the assignment at line 8 which would enable this code to compile correctly. It is planned in the future to extend the compiler to support this pull (as well as push) remote memory mechanism.

← Older revision		Revision as of 11:55, 17 January 2013
Line 51:		Line 51:

	The code snippet above is similar to the first one but with some important differences. We are declaring two variables; the first, ''a'', is held on process zero only whereas the second, ''b'', is allocated to all processes. Process zero then alone (via the [[Proc\|proc]] statement will modify ''a'' locally (as it is held there) and then assign ''b'' to be the value of ''a''. We then [[Sync\|synchronise]] based upon variable ''b'' and process one will display its value of ''b''. Stepping back a moment, what we are basically doing here is assigning a value to a variable allocated on all processes from one allocated on a single process. The result is that process zero will write the value of variable ''a'' into ''b'' on all processes (it is a broadcast.) If you remove the [[Sync\|sync]] statement on line 11 then you will see that instead of displaying the value ''1'', ''0'' is displayed (the default [[Int]] initialisation value.) This is because synchronisation must occur to update this remote value on process one from process zero.		The code snippet above is similar to the first one but with some important differences. We are declaring two variables; the first, ''a'', is held on process zero only whereas the second, ''b'', is allocated to all processes. Process zero then alone (via the [[Proc\|proc]] statement will modify ''a'' locally (as it is held there) and then assign ''b'' to be the value of ''a''. We then [[Sync\|synchronise]] based upon variable ''b'' and process one will display its value of ''b''. Stepping back a moment, what we are basically doing here is assigning a value to a variable allocated on all processes from one allocated on a single process. The result is that process zero will write the value of variable ''a'' into ''b'' on all processes (it is a broadcast.) If you remove the [[Sync\|sync]] statement on line 11 then you will see that instead of displaying the value ''1'', ''0'' is displayed (the default [[Int]] initialisation value.) This is because synchronisation must occur to update this remote value on process one from process zero.
		+
		+	#include <io>
		+	#include <string>
		+
		+	function void main() {
		+	var a:Int::allocated[multiple[commgroup[0,2]]];
		+	proc 1 {
		+	a:=2;
		+	};
		+	sync a;
		+	group 0, 2 {
		+	print(itostring(a)+"\n");
		+	};
		+	};
		+
		+	The same thing will happen with [[Commgroup\|communication groups]] too compile and run the following code, you will see that process one has written the value ''2'' into the memory of variable ''a'' which is held on processes zero and two.
		+
		+	== Single to single ==
		+
		+	If we have two variables which are allocated to single processes then any assignment involving these will either result in local or remote access depending on whether they are on the same process or not.
		+
		+	#include <io>
		+	#include <string>
		+
		+	var processOneAllocation:=0;
		+	var processTwoAllocation:=0;
		+
		+	function void main() {
		+	var a:Int::allocated[single[on[processOneAllocation]]];
		+	var b:Int::allocated[single[on[processTwoAllocation]]];
		+	proc processTwoAllocation {
		+	b:=23;
		+	a:=b;
		+	};
		+	//sync a;
		+	group processOneAllocation {
		+	print(itostring(a)+"\n");
		+	};
		+	};
		+
		+	In the example above we are allocating variables ''a'' and ''b'' both on process zero, we are then performing an assignment ''a:=b'' at line 12 which, because the variables are on the same process is local and occurs immediately. Now, change ''processOneAllocation'' to be equal to ''1'' and uncomment the [[Sync\|sync]] keyword at line 14 and recompile and run. See the same value - but now process 0 is writing the value of ''b'' into the remote memory of ''a'' and if you comment out the [[Sync\|sync]] keyword then a value of ''0'' will be reported. The values of ''processOneAllocation'' and ''processTwoAllocation'' can be anything - if they are the same here then it is local and if not then remote.
		+
		+	== Limits of communication ==