### Other Coordination Patterns

Suppose processes are cooperating in a search to find a value, *xmax*, that maximizes a function *F*; that is, *F(xmax)* is the greatest value *F* attains. Each process has its own list of *x* values to test. We would like to do something like:

for x in MyCandidateList: currentMax = ws.fetch('max') y = f(x) if y > currentMax: ws.store('max', y)

But that would be wrong, since *fetch* consumes a value that may not be replaced.

We would like a way to consult a variable without destroying the value. In NWS, *find* returns a value without destroying it. So, we could try:

for x in MyCandidateList: currentMax = ws.find('max') y = f(x) if y > currentMax: ws.store('max', y)

But that would be wrong too—we are no longer maintaining a single maximum value, and *currentMax* might not really be current. How about:

for x in MyCandidateList: currentMax = ws.find('max') y = f(x) if y > currentMax: currentMax = ws.fetch('max') if y > currentMax: currentMax = y ws.store('max', currentMax)

Now we're only updating *max* when our *currentMax* really is larger. Because of the *fetch/store* pair, we have just one value associated with *max* (this pair of operations also ensures the atomicity of the update). But suppose it is unlikely that a given *x* will result in a new maximum. We could further reduce the coordination traffic by invoking *find* only every other iteration or every tenth or... Because we always consult the true current value of *max* before committing to a change, stale values won't lead to incorrect results. They will, however, increase the number of failed update attempts.

There are other uses for *find*, the most common being "write-once" variables such as initialization data that are set at the beginning of a computation and needed by two or more ensemble members.

*find* alters the way value queues are referenced. What about variations in the queue itself? NWS supports four modes for values:

- First-In-First-Out (the default).
- Last-In-First-Out.
- Nondeterministic (not random, just arbitrary).
- Single (the variable only holds one value;
*store*overwrites the previous value, if any).

The single mode works well with the *find* operation and is useful for status values; you can update the status without bothering to remove (*fetch*) the previous status.

from nws.client import SINGLE ws.declare('status', SINGLE) while True: time.sleep(60) status=... ws.store('status', status)