Threshold selection for Event-Triggered Communication

[soumyadipghosh]

Till now, I was using a threshold of the form alpha * beta^k where alpha is any constant, beta is a constant between 0 and 1 and k is the iteration number. This threshold decreases with iterations and goes to zero asymptotically. When an event for communication is not triggered at the sender, the receiver keeps using the last communicated values for its own local solve. I think there are two problems with this scheme (seen through experiments) :

• The threshold is dependent on time (iterations) but it is not dependent on space. In other words, it decreases with iterations but every PE uses the same threshold during a particular iteration regardless of its location in the domain. This is not desired since the rate of change of boundary values in a PE will be different from another PE depending on the initial conditions. Therefore threshold has to be made space dependent.

• When the receiver does not receive a new value because an event for communication was not triggered in the corresponding sender, using the last communicated value for its own local solve at the receiver will lead to the same local solution again (the "local" boundary conditions for the receiver stays the same and hence it converges to the same solution). As a result, the receiver's boundary values don't change and hence an event for communication is not triggered unless fresh values come to it from neighbors. This situation often leads to a "communication deadlock" (a processor does not trigger communication unless it receives new values, the same holds for its neighbors and so on). A possible solution is to extrapolate the ghost cells at the receiver using last received values so that the local solve yields a different local solution, leading to change in its boundary values which may trigger a communication.

Please comment what you think.

[pratikvn]

Feel free to correct this if anything is incorrect: If we take threshold, θ = α * (β^k), the properties we need are:

1. Asymptotic reduction to zero as iterations increase, θ->0 |_k->∞
2. threshold to be non-negative; (θ>0).
3. threshold has some upper limit, T ; (θ≤T)

Some implications on α and β are:

• 0<α≤1.
• 0<β<1.

Some thoughts:

1. k does not have to be the iteration number. If we see that we need a faster rate of reduction, we can use k≡2*k, k≡k².
2. I think θ = α * (β^k) is an acceptable generic modelling of the threshold. We need a better way to choose α and β.
   • I think as a start, α can be let a free parameter to tune the rate of reduction
   • β could be a parameter that depends on the solution values, either directly 'solution(k)/solution(k-1)' or a simple additive differential of the solution (f(x+h)-f(x)/(h)) or depending on the residual (residual(k)/residual(k-1)) or normalized on the initial residual (residual(k)/residual(0)).
3. Extrapolation of the interface values sounds good. It could be a good idea to start with just linear extrapolation. The question is what values would you send to the neighbors, the previous solution values or the new solution values computed from the boundary extrapolated values ?