Currently, for an array variable, changing an element requires the developer to read the array, update the element and write the array out. Whilst this is fine for simple cases with not sophisticated data flows, it becomes very cumbersome for cases when parallel processing is introduced. For instance, multiple loops updating an array of status flags.
At present, if two loops (which may be in different Vis) both execute a read-update-write operation on a global shared variable, data can be lost if the operations happen at similar times. Consider the following example:
Looking at the image above, let's imagine "array1" consists of two elements with values F and T respectively. Then the operation would happen as follows:
|
Step Number
|
Action taken
|
Array values
|
|
1.
|
Read "array1"
|
F and T
|
|
2.
|
Read "array1"
|
F and T
|
|
3.
|
Update "array1" element 0 to T
|
T and T
|
|
4.
|
Update "array1" element 1 to F
|
F and F
|
|
5.
|
Write to "array1"
|
T and T
|
|
6.
|
Write to "array1"
|
F and F
|
Hence all the data written by “Loop A” is lost. Putting user-defined locking using shared variables around the operations does not seem to work, presumably due to update rate of the locking variables.
What would be helpful to overcome these race conditions is to replicate the functionality present in other languages to do operations like a[3]=4 or printf(“%lf”,a[4]). In these cases, an atomic operation is performed to get or set the value in the defined memory location. The addition of this functionality to shared variables would be extremely powerful.
An example of such functionality could look something like this:
