Tutorial - Arrays - Revision history

Polas: 11 revisions imported

2019-04-15T15:44:59Z

11 revisions imported

Polas at 11:43, 19 October 2016

2016-10-19T11:43:31Z

Polas: /* Communication of arrays */

2016-10-18T12:12:25Z

‎Communication of arrays

Polas at 16:21, 31 January 2013

2013-01-31T16:21:51Z

Polas at 18:28, 19 January 2013

2013-01-19T18:28:00Z

Polas: /* Row and column major */

2013-01-17T15:55:49Z

‎Row and column major

Polas: /* Row and column major */

2013-01-17T14:26:19Z

‎Row and column major

Polas: /* Row and column major */

2013-01-17T14:26:08Z

‎Row and column major

Polas at 14:06, 17 January 2013

2013-01-17T14:06:54Z

Polas at 14:00, 17 January 2013

2013-01-17T14:00:45Z

@@ Line 1: / Line 1: @@
 <metadesc>Tutorial describing collecting data together via arrays in Mesham</metadesc>
-'''Tutorial number seven''' - [[Tutorial_-_Parallel Types|prev]] :: [[Tutorial_-_Dynamic Parallelism|next]]
+'''Tutorial number seven''' - [[Tutorial_-_Parallel Types|prev]] :: [[Tutorial_-_RMA|next]]
 == Introduction ==

@@ Line 80: / Line 80: @@
         a[0][1]:=28;
      };
-     sync a;
+     sync;
      proc 1 {
         print(itostring(a[0][1])+"\n");
@@ Line 101: / Line 101: @@
         };
      };
-     sync a;
+     sync;
      proc 1 {
         var i;
@@ Line 110: / Line 110: @@
   };
-Compile and run this code - look at the output, it is just a list of the value ''8'', not what you expected? Well this is to be expected because at each assignment ''a[2][i]:=i;'' we are setting the remote value of ''a'' at this specific index to be the value held in ''i''. However, this does not complete until the [[Sync|synchronisation]] and at that point the value of ''i'' is ''8'' (the loop iterates up to and including 7, after which ''i'' is incremented but found to be too large and the loop ceases.) It is something to be aware of - the value of a variable being remotely written ''matters'' until after the corresponding synchronisation.
+Compile and run this code - look at the output, is it just a list of the value ''8'', not what you expected? Well in this example the values copied across may be any number between 0 and 8 because at each assignment ''a[2][i]:=i;'' we are setting the remote value of ''a'' at this specific index to be the value held in ''i''. However, this communication does not guarantee to complete until the [[Sync|synchronisation]] and at that point the value of ''i'' is ''8'' (the loop iterates up to and including 7, after which ''i'' is incremented but found to be too large and the loop ceases.) It is something to be aware of - the value of a variable being remotely written ''matters'' until after the corresponding synchronisation.
 There are a number of ways in which we could change this code to make it do what we want, the easiest is to use a temporary variable allocated on the heap (and will be garbage collected after the synchronisation.) To do this, replace the ''proc 0'' block with:

@@ Line 1: / Line 1: @@
 <metadesc>Tutorial describing collecting data together via arrays in Mesham</metadesc>
-'''Tutorial number seven''' - [[Tutorial_-_Parallel Types|prev]]
+'''Tutorial number seven''' - [[Tutorial_-_Parallel Types|prev]] :: [[Tutorial_-_Dynamic Parallelism|next]]
 == Introduction ==

← Older revision		Revision as of 18:28, 19 January 2013
Line 1:		Line 1:
		+	<metadesc>Tutorial describing collecting data together via arrays in Mesham</metadesc>
		+	'''Tutorial number seven''' - [[Tutorial_-_Parallel Types\|prev]]
		+
	== Introduction ==		== Introduction ==

← Older revision		Revision as of 15:55, 17 January 2013
Line 157:		Line 157:

	will allocate array ''a'' to be an [[Int]] array of 16 by 8, allocated to all processes using column major memory allocation.		will allocate array ''a'' to be an [[Int]] array of 16 by 8, allocated to all processes using column major memory allocation.
		+
		+	For something more interesting let's have a look at the following code:
		+
		+	#include <io>
		+	#include <string>
		+
		+	function void main() {
		+	var a:array[Int,16,8];
		+	var i;
		+	var j;
		+	for i from 0 to 15 {
		+	for j from 0 to 7 {
		+	a[i][j]:=(i*10) + j;
		+	};
		+	};
		+	print(itostring(a::col[][14][7]));
		+	};
		+
		+	By default variable ''a'' is [[Row\|row major]] allocated and we are filling up the array in this fashion. However, in the [[Print\|print]] statement we are accessing the indexes of this array in a [[Col\|column major]] fashion. Try changing [[Col\|col]] to [[Row\|row]] or remove it altogether to see the difference in value. Behind the scenes the types are doing to appropriate memory look up based upon their meaning and the indexes provided. Mixing memory allocation in this manner can be very useful for array transposition amongst other things. ''Exercise:'' Experiment with the [[Col\|col]] and [[Row\|row]] types and also see what effect it has placing them in the type chain of ''a'' like in the previous example.
		+
	[[Category: Tutorials\|Arrays]]		[[Category: Tutorials\|Arrays]]

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

← Older revision		Revision as of 14:26, 17 January 2013
Line 157:		Line 157:

	will allocate array ''a'' to be an [[Int]] array of 16 by 8, allocated to all processes using column major memory allocation.		will allocate array ''a'' to be an [[Int]] array of 16 by 8, allocated to all processes using column major memory allocation.
−	[[Category: Tutorials]]	+	[[Category: Tutorials\|Arrays]]

← Older revision		Revision as of 14:26, 17 January 2013
Line 149:		Line 149:

	== Row and column major ==		== Row and column major ==
		+
		+	By default arrays are row major allocated using the [[Row\|row]] type. This can be overridden to column major via the [[Col\|col]] type.
		+
		+	function void main() {
		+	var a:array[Int,16,8]::allocated[col::multiple];
		+	};
		+
		+	will allocate array ''a'' to be an [[Int]] array of 16 by 8, allocated to all processes using column major memory allocation.
		+	[[Category: Tutorials]]

@@ Line 84: / Line 84: @@
 In this example process 0 writes to the (remote) memory of process 1 which contains the array, synchronisation occurs and then the value is displayed by process 1 to standard output.
   #include <io>
@@ Line 118: / Line 120: @@
   };
 == Row and column major ==

← Older revision		Revision as of 14:00, 17 January 2013
Line 52:		Line 52:
	};		};

−	This code demonstrates passing arrays into functions and there are a couple of noteworthy points to make here. First, because an [[Array\|array]] is, by default, allocated to the [[Heap\|heap]], as discussed in the [[~~Tutorials~~ - Functions\|functions tutorial]], this is pass by reference. Hence modifications made in the ''fill'' function do affect the original data allocated in the ''main'' function, which is what we want here. Secondly, see that the type we provide to the ''display'' function does not have any explicit size associated with the array? It is not always possible to know the size of an array that is being passed into a function, so Mesham allows for the type of a function argument to be specified with a size but with two restrictions; first it must be a one dimensional array and secondly no compile time bounds checking can take place.	+	This code demonstrates passing arrays into functions and there are a couple of noteworthy points to make here. First, because an [[Array\|array]] is, by default, allocated to the [[Heap\|heap]], as discussed in the [[Tutorial - Functions\|functions tutorial]], this is pass by reference. Hence modifications made in the ''fill'' function do affect the original data allocated in the ''main'' function, which is what we want here. Secondly, see that the type we provide to the ''display'' function does not have any explicit size associated with the array? It is not always possible to know the size of an array that is being passed into a function, so Mesham allows for the type of a function argument to be specified with a size but with two restrictions; first it must be a one dimensional array and secondly no compile time bounds checking can take place.
		+
		+	=== Multi dimensional arrays ===
		+
		+	Arrays can be any number of dimensions just by adding extra bounds into the type declaration:
		+
		+	function void main() {
		+	var a:array[Int,16,8];
		+	a[0][1]:=23;
		+	};
		+
		+	This code illustrates declaring variable ''a'' to be an [[Array\|array]] of two dimensions; the first of size 16 and the second 8. By default all allocation of arrays is [[Row\|row major]] although this can be overridden. Line three illustrates writing into an element of a two dimensional array.
		+
		+	== Communication of arrays ==
		+
		+	Arrays can be communicated entirely, per dimension or by individual elements.
		+
		+	#include <io>
		+	#include <string>
		+
		+	function void main() {
		+	var a:array[Int,16,8]::allocated[single[on[1]]];
		+	proc 0 {
		+	a[0][1]:=28;
		+	};
		+	sync a;
		+	proc 1 {
		+	print(itostring(a[0][1])+"\n");
		+	};
		+	};
		+
		+	In this example process 0 writes to the (remote) memory of process 1 which contains the array, synchronisation occurs and then the value is displayed by process 1 to standard output.
		+
		+	#include <io>
		+	#include <string>
		+
		+	function void main() {
		+	var a:array[Int,16,8]::allocated[single[on[1]]];
		+	proc 0 {
		+	var i;
		+	for i from 0 to 7 {
		+	a[2][i]:=i;
		+	};
		+	};
		+	sync a;
		+	proc 1 {
		+	var i;
		+	for i from 0 to 7 {
		+	print(itostring(a[2][i])+"\n");
		+	};
		+	};
		+	};
		+
		+	Compile and run this code - look at the output, it is just a list of the value ''8'', not what you expected? Well this is to be expected because at each assignment ''a[2][i]:=i;'' we are setting the remote value of ''a'' at this specific index to be the value held in ''i''. However, this does not complete until the [[Sync\|synchronisation]] and at that point the value of ''i'' is ''8'' (the loop iterates up to and including 7, after which ''i'' is incremented but found to be too large and the loop ceases.) It is something to be aware of - the value of a variable being remotely written ''matters'' until after the corresponding synchronisation.
		+
		+	There are a number of ways in which we could change this code to make it do what we want, the easiest is to use a temporary variable allocated on the heap (and will be garbage collected after the synchronisation.) To do this, replace the ''proc 0'' block with:
		+
		+	proc 0 {
		+	var i;
		+	for i from 0 to 7 {
		+	var m:Int::heap;
		+	m:=i;
		+	a[2][i]:=m;
		+	};
		+	};
		+
		+
		+	== Row and column major ==