The Wikipedia article mentions non-determinism in the context of dataflow architectures. Arthur Veen's paper mentions non-determinism when it elaborates on MERGE nodes as conditional constructs.
Are dataflow architectures non-deterministic in the sense of Non-Deterministic Turing Machine?
For any program which deterministically runs on a von Neumann architecture, can we guarantee that it runs deterministically on a data flow architecture?
Are dataflow architectures non-deterministic in the sense of Non-Deterministic Turing Machine?
In principle one could create a non-deterministic dataflow architecture, but that would be a bit odd. There is nothing about dataflow that fundamentally requires determinism or non-determinism.
Normally I'd expect that a dataflow architecture would be deterministic in the sense that the result of the computation is a deterministic function of the inputs (in principle it doesn't have to be that way, but that's probably the common case for a dataflow architecture). Of course, the order in which intermediate values are computed might not be deterministic, even though the result is. See Why doesn't parallelism necessarily imply non-determinism? for a detailed explanation of that point.
Beware that there are multiple meanings of the word "non-determinism". One meaning is non-determinism in the sense of a non-deterministic Turing machine, i.e., there can be a choice of transitions and the machine magically makes the best choice at every step; this is not implementable directly in real-world machines, so is purely a theoretical nothing. Another meaning is that the system is not deterministic, e.g., there are aspects of its behavior that are not specified or random; those are resolved somehow but not necessarily by choosing the best choice. Occasionally I've seen people use the word "indeterminism" for the latter notion, but that seems to be pretty rare. See also Differences and relationships between randomized and nondeterministic algorithms?, https://cs.stackexchange.com/a/38158/755, https://en.wikipedia.org/wiki/Nondeterministic_algorithm, https://en.wikipedia.org/wiki/Indeterminacy_in_computation.
Dataflow architectures are more nondeterministic than a nondeterministic Turing Machine.
With a nondeterministic Turing Machine, you still have a single machine that performs all the actions. All input is predetermined, it is already on the input tape. The only nondeterminism in the system is in the choice of the next transition, for which multiple options may exist. Time is not a factor at all.
With a dataflow architecture, we may have any number of different data processing components, operating concurrently. The input isn't predetermined, but it streams in on the input channels, with unpredictable values and possibly at unpredictable rates. The system's behavior may be strongly affected by the value of the data items flowing in, the relative order at which they flow in on different channels, and time-related factors (e.g. how fast they flow in). So the amount of nondeterminism is generally much higher.
