Async - Revision history

Polas: 5 revisions imported

2019-04-15T15:44:36Z

5 revisions imported

Polas at 14:16, 15 April 2013

2013-04-15T14:16:59Z

Polas at 18:43, 13 January 2013

2013-01-13T18:43:53Z

Polas at 18:16, 13 January 2013

2013-01-13T18:16:18Z

Polas at 17:49, 12 January 2013

2013-01-12T17:49:40Z

Polas: Created page with '== Syntax == async[ ] == Semantics == This type will specify that the communication to be carried out should be done so asynchronously. Asynchronous communication is often ver…'

2010-01-10T19:40:11Z

Created page with '== Syntax == async[ ] == Semantics == This type will specify that the communication to be carried out should be done so asynchronously. Asynchronous communication is often ver…'

New page

== Syntax ==

async[ ]

== Semantics ==

This type will specify that the communication to be carried out should be done so asynchronously. Asynchronous communication is often very useful and, if used correctly, can increase the efficiency of some applications (although care must be taken.) There are a number of different ways that the results of asynchronous communication can be accepted, when the asynchronous operation is honoured then the data is placed into the variable, however when exactly the operation will be honoured is none deterministic and care must be taken if using dirty values.

The [[sync]] keyword allows the programmer to either synchronise ALL or a specific variable's asynchronous communication. The programmer must ensure that all asynchronous communications have been honoured before the process exits, otherwise bad things will happen!

== Examples ==

var a:Int::allocated[multiple[]] :: channel[0,1] :: async[];
var p;
par p from 0 to 2
{
a:=89;
var q:=20;
q:=a;
sync q;
};

In this example, ''a'' is declared to be an integer, allocated to all processes, and to act as an asynchronous channel between processes 0 and 1. In the par loop, the assignment ''a:=89'' is applicable on process 0 only, resulting in an asynchronous send. Each process executes the assignment and declaration ''var q:=20'' but only process 1 will execute the last assignment ''q:=a'', resulting in an asynchronous receive. Each process then synchronises all the communications relating to variable ''q''.

var a:Int::allocated[single[on[1]]];
var b:Int::allocated[single[on[2]]] :: async[];
var c:Int::allocated[single[on[3]]] :: async[];
a:=b;
c:=a;
b:=c;
sync;

This example demonstrates the use of the ''async'' type in terms of default shared variable style communication. In the assignment ''a:=b'', processor 2 will issue an asynchronous send and processor 1 will issue a synchronous (standard) receive. The second assignment, ''c:=a'', processor 3 will issue an asynchronous receive and processor 1 a synchronous send. In the last assignment, ''b:=c'', both processors (3 and 2) will issue asynchronous communication calls (send and receive respectively.) The last line of the program will force each process to wait and complete all asynchronous communications.

[[Category:Type Library]]
[[Category:Composite Types]]
[[Category:Communication Mode Types]]

@@ Line 34: / Line 34: @@
 This example demonstrates the use of the ''async'' type in terms of default shared variable style communication. In the assignment ''a:=b'', processor 2 will issue an asynchronous send and processor 1 will issue a synchronous (standard) receive. The second assignment, ''c:=a'', processor 3 will issue an asynchronous receive and processor 1 a synchronous send. In the last assignment, ''b:=c'', both processors (3 and 2) will issue asynchronous communication calls (send and receive respectively.) The last line of the program will force each process to wait and complete all asynchronous communications.
-''Since: Version 0.41b''
+''Since: Version 0.5''
 [[Category:Type Library]]
 [[Category:Compound Types]]
 [[Category:Communication Mode Types]]

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

@@ Line 11: / Line 11: @@
 == Examples ==
+ function void main() {
- var a:Int::allocated[multiple[]] :: channel[0,1] :: async[];
+    var a:Int::allocated[multiple[]] :: channel[0,1] :: async[];
- var p;
+    var p;
- par p from 0 to 2
+    par p from 0 to 2 {
+       a:=89;
-    a:=89;
+       var q:=20;
-    var q:=20;
+       q:=a;
-    q:=a;
+       sync q;
-    sync q;
+    };
   };
 In this example, ''a'' is declared to be an integer, allocated to all processes, and to act as an asynchronous channel between processes 0 and 1. In the par loop, the assignment ''a:=89'' is applicable on process 0 only, resulting in an asynchronous send. Each process executes the assignment and declaration ''var q:=20'' but only process 1 will execute the last assignment ''q:=a'', resulting in an asynchronous receive. Each process then synchronises all the communications relating to variable ''q''.
-  var a:Int::allocated[single[on[1]]];
+  function void main() {
- var b:Int::allocated[single[on[2]]] :: async[];
+    var a:Int::allocated[single[on[1]]];
- var c:Int::allocated[single[on[3]]] :: async[];
+    var b:Int::allocated[single[on[2]]] :: async[];
- a:=b;
+    var c:Int::allocated[single[on[3]]] :: async[];
- c:=a;
+    a:=b;
- b:=c;
+    c:=a;
-  sync;
+    b:=c;
 This example demonstrates the use of the ''async'' type in terms of default shared variable style communication. In the assignment ''a:=b'', processor 2 will issue an asynchronous send and processor 1 will issue a synchronous (standard) receive. The second assignment, ''c:=a'', processor 3 will issue an asynchronous receive and processor 1 a synchronous send. In the last assignment, ''b:=c'', both processors (3 and 2) will issue asynchronous communication calls (send and receive respectively.) The last line of the program will force each process to wait and complete all asynchronous communications.