Distributed temporaries

[Richard Guenther]

Hi!

A while back I asked how to best create distributed temporary arrays with
internal guards but with completely locally managed (internal) guards. I
figured out there is no way to do this (cleanly) at the moment.

There are two ways to hack around this problem:
1. create an extra layout for the temps and clear the layouts gcFillList_m
vector
2. every time you write to the temps, block and evaluate and then clear
the dirty flag of the engine

While 1. seems to be somehow reasonable (you could even add new
constructors with a tag that dont fill the list in the first place),
adding a separate MultiPatch engine which doesnt manage the
internal guards would be another possibility. This can be done by
either adding a template argument to the existing MultiPatch engine or by
copying and stripping it down.

Any suggestions on which is the recommended/better way to do this?

Just to motivate this a little bit more - having code like:

Field A, B, C;
...
{
   Field temp;
   temp.all() = A + 2.0*B;
   C(I) = (1.0 - temp(I)) * where(A > 0.0, temp(I+1), temp(I-1));
}

referencing temp would exchange internal guards even if this is not
strictly necessary.

In the long run we maybe want to make the dirty flag more fine-grained so
we can just update really dirty data (we have exact domain information for
reading and writing operations, dont we?). I.e. for each patch have an
array of 2*dim Interval<dim>'s which hold the currently dirty domain, at
gc exchange time we can just intersect this with the gcFillList domains
and skip unnecessary ones. (This does also help directional splitted
code!)

Well - things to try out for someone with lots of spare time ;)

Richard.

--
Richard Guenther <address@hidden>
WWW: http://www.tat.physik.uni-tuebingen.de/~rguenth/
The GLAME Project: http://www.glame.de/